@o-lang/semantic-doc-search 1.0.35 → 1.0.37

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@o-lang/semantic-doc-search",
-  "version": "1.0.35",
+  "version": "1.0.37",
   "description": "O-lang Semantic Document Search Resolver with hybrid search, embeddings, rerank, and streaming.",
   "main": "src/index.js",
   "type": "commonjs",

package/src/adapters/VectorAdapter.js

@@ -4,8 +4,18 @@ class VectorAdapter {
     this.dimension = config.dimension || null;
   }
 
+  /**
+   * Validates vector input.
+   * Accepts: 
+   *   - Plain arrays (e.g., [0.1, -0.2, ...])
+   *   - TypedArrays (e.g., Float32Array)
+   */
   validateVector(vector) {
-    if (!Array.isArray(vector)) throw new Error("Vector must be an array");
+    // ✅ Allow both Array and TypedArray (Float32Array, etc.)
+    if (!Array.isArray(vector) && !ArrayBuffer.isView(vector)) {
+      throw new Error("Vector must be an array or TypedArray");
+    }
+    
     if (this.dimension && vector.length !== this.dimension) {
       throw new Error(
         `Vector dimension mismatch: expected ${this.dimension}, got ${vector.length}`
@@ -25,4 +35,4 @@ class VectorAdapter {
   }
 }
 
-module.exports = VectorAdapter;
+module.exports = VectorAdapter;

package/src/index.js

@@ -1,256 +1,9 @@
-const fs = require("fs");
-const path = require("path");
-const embedder = require("./embeddings/local.js"); // ✅ singleton embedder
-const { chunkText } = require("./utils/chunker.js");
-const { extractKeywords } = require("./utils/extractText.js");
-const { highlightMatches } = require("./utils/highlight.js");
-const VectorRouter = require("./adapters/vectorRouter");
-const PgVectorAdapter = require("./adapters/pgvectorAdapter.js");
-
-const CACHE_PATH = path.join(process.cwd(), "embeddings.json");
-
-/* ---------------- UTIL ---------------- */
-
-function safeResolve(base, userPath) {
-  const resolved = path.resolve(base, userPath);
-  if (!resolved.startsWith(path.resolve(base))) {
-    throw new Error("Path traversal detected");
-  }
-  return resolved;
-}
-
-function loadCache() {
-  try {
-    if (fs.existsSync(CACHE_PATH)) {
-      return JSON.parse(fs.readFileSync(CACHE_PATH, "utf8")) || {};
-    }
-  } catch {}
-  return {};
-}
-
-function saveCache(cache) {
-  try {
-    fs.writeFileSync(CACHE_PATH, JSON.stringify(cache, null, 2));
-  } catch {}
-}
-
-/* ---------------- DATABASE ADAPTER ---------------- */
-
-class DatabaseAdapter {
-  constructor() {
-    this.initialized = false;
-  }
-
-  async initialize(context) {
-    if (this.initialized) return;
-
-    if (context.MONGO_URI) await this.initMongo(context);
-    else if (context.db_path) await this.initSQLite(context);
-    else if (context.POSTGRES_URL) await this.initPostgres(context);
-
-    this.initialized = true;
-  }
-
-  async initSQLite(context) {
-    const Database = require("better-sqlite3");
-    const dbPath = context.db_path || "./database.db";
-    this.sqlite = new Database(dbPath, { readonly: true });
-  }
-
-  async initMongo(context) {
-    const { MongoClient } = require("mongodb");
-    this.mongo = new MongoClient(context.MONGO_URI);
-    await this.mongo.connect();
-  }
-
-  async initPostgres(context) {
-    const { Pool } = require("pg");
-    this.pg = new Pool({ connectionString: context.POSTGRES_URL });
-  }
-
-  async queryDocuments(context) {
-    const table = context.db_table || "documents";
-    const idCol = context.db_id_column || "id";
-    const contentCol = context.db_content_column || "content";
-
-    if (this.mongo) {
-      const rows = await this.mongo.db().collection(table).find({}).toArray();
-      return rows.map(r => ({
-        id: r._id.toString(),
-        content: r[contentCol] || "",
-        source: `mongodb:${table}`,
-      }));
-    }
-
-    if (this.sqlite) {
-      const rows = this.sqlite
-        .prepare(`SELECT ${idCol}, ${contentCol} FROM ${table}`)
-        .all();
-      return rows.map(r => ({
-        id: r[idCol],
-        content: r[contentCol],
-        source: `sqlite:${table}`,
-      }));
-    }
-
-    if (this.pg) {
-      const res = await this.pg.query(
-        `SELECT ${idCol}, ${contentCol} FROM ${table}`
-      );
-      return res.rows.map(r => ({
-        id: r[idCol],
-        content: r[contentCol],
-        source: `postgres:${table}`,
-      }));
-    }
-
-    return [];
-  }
-}
-
-/* ---------------- DOCUMENT LOADING ---------------- */
-
-async function loadAllDocuments(context) {
-  const docs = [];
-  const db = new DatabaseAdapter();
-
-  try {
-    await db.initialize(context);
-    docs.push(...(await db.queryDocuments(context)));
-  } catch {}
-
-  const baseDir = context.doc_root
-    ? safeResolve(process.cwd(), context.doc_root)
-    : path.join(process.cwd(), "docs");
-
-  if (fs.existsSync(baseDir)) {
-    const files = fs
-      .readdirSync(baseDir)
-      .filter(f => f.endsWith(".txt") || f.endsWith(".md"));
-
-    for (const file of files) {
-      docs.push({
-        id: file,
-        content: fs.readFileSync(path.join(baseDir, file), "utf8"),
-        source: `file:${file}`,
-      });
-    }
-  }
-
-  return docs;
-}
-
-/* ---------------- HYBRID VECTOR SEARCH ---------------- */
-
-async function performHybridDocQA(query, context) {
-  const cache = loadCache();
-
-  const MIN_SCORE = context.minScore ?? 0.75;
-  const topK = context.topK ?? 5;
-
-  const vectorStore = VectorRouter.create({
-    backend: context.vectorBackend || "memory",
-    dimension: embedder.getDimension(),
-    ...context,
-  });
-
-  console.log(
-    "🧠 Vector store methods:",
-    Object.getOwnPropertyNames(Object.getPrototypeOf(vectorStore))
-  );
-
-  const documents = await loadAllDocuments(context);
-  console.log("📄 Documents loaded:", documents.length);
-
-  if (!documents.length) return { text: "(No documents found)", meta: { matches: 0 } };
-
-  // Multi-document ingestion
-  for (const doc of documents) {
-    const chunks = chunkText(doc.content, 500);
-    console.log(`📦 ${doc.id} split into ${chunks.length} chunks`);
-
-    for (let i = 0; i < chunks.length; i++) {
-      console.log("🧩 Chunk to embed:", chunks[i]?.substring(0, 100));
-
-      const vector = await embedder.embed(chunks[i]);
-      if (!vector || vector.every(v => v === 0)) {
-        console.warn("⚠️ Zero or invalid embedding, skipping chunk");
-        continue;
-      }
-
-      await vectorStore.upsert({
-        id: `${doc.id}:${i}`,
-        vector,
-        content: chunks[i],
-        source: doc.source,
-      });
-
-      console.log(`✅ Upserted ${doc.id}:${i}`);
-    }
-  }
-
-  saveCache(cache);
-
-  // Embed the query
-  const queryVector = await embedder.embed(query);
-  if (!queryVector || queryVector.every(v => v === 0)) {
-    console.warn("⚠️ Query embedding invalid");
-    return { text: "(Query could not be embedded)", meta: { matches: 0 } };
-  }
-
-  // Top-K + similarity threshold
-  const results = await vectorStore.query(queryVector, { topK });
-  const filtered = results.filter(r => r.score >= MIN_SCORE);
-
-  console.log(`🔍 Search results: ${filtered.length} (after applying minScore=${MIN_SCORE})`);
-
-  if (!filtered.length) {
-    return { text: "(No relevant match found)", meta: { matches: 0 } };
-  }
-
-  return {
-    text: highlightMatches(
-      filtered.map(r => r.content).join("\n\n"),
-      extractKeywords(query)
-    ),
-    meta: { matches: filtered.length },
-  };
-}
-
-
-/* ---------------- PGVECTOR SEARCH ---------------- */
-
-async function performPgVectorSearch(query, context) {
-  const adapter = new PgVectorAdapter({
-    POSTGRES_URL: context.POSTGRES_URL,
-  });
-
-  const vector = await embedder.embed(query);
-  const results = await adapter.search(vector, 5);
-  await adapter.close();
-
-  return {
-    text: results.map(r => r.content).join("\n\n"),
-    meta: { matches: results.length },
-  };
-}
-
-/* ---------------- ROUTER ---------------- */
-
-async function performDocQA(query, context) {
-  if (context.POSTGRES_URL) {
-    return performPgVectorSearch(query, context);
-  }
-  return performHybridDocQA(query, context);
-}
-
-/* ---------------- O-LANG RESOLVER ---------------- */
-
-const semanticResolver = require("./resolver"); // ✅ IMPORT NEW FILE
+// index.js (6 lines)
+const semanticResolver = require("./resolver");
 
 async function docSearchResolver(action, context) {
-  return semanticResolver(action, context);
+  return await semanticResolver(action, context);
 }
 
 docSearchResolver.resolverName = "doc-search";
-module.exports = docSearchResolver;
+module.exports = docSearchResolver;