@o-lang/semantic-doc-search 1.0.22 → 1.0.23

package/package.json

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

package/src/index.js

@@ -1,16 +1,16 @@
 const fs = require("fs");
 const path = require("path");
-const { createLLM } = require("./llm/router.js");
 const { LocalEmbedding } = require("./embeddings/local.js");
 const { chunkText } = require("./utils/chunker.js");
 const { extractKeywords } = require("./utils/extractText.js");
-const { cosine } = require("./utils/similarity.js");
 const { highlightMatches } = require("./utils/highlight.js");
-const PgVectorAdapter = require("./adapters/pgvectorAdapter.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))) {
@@ -44,13 +44,9 @@ class DatabaseAdapter {
   async initialize(context) {
     if (this.initialized) return;
 
-    if (context.db_type === "mongodb" || context.MONGO_URI) {
-      await this.initMongo(context);
-    } else if (context.db_type === "sqlite" || context.db_path) {
-      await this.initSQLite(context);
-    } else if (context.db_type === "postgres" || context.POSTGRES_URL) {
-      await this.initPostgres(context);
-    }
+    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;
   }
@@ -58,74 +54,51 @@ class DatabaseAdapter {
   async initSQLite(context) {
     const Database = require("better-sqlite3");
     const dbPath = context.db_path || "./database.db";
-    const dbDir = path.dirname(path.resolve(dbPath));
-    if (!fs.existsSync(dbDir)) {
-      throw new Error(`SQLite database directory not found: ${dbDir}`);
-    }
-    this.sqliteClient = new Database(dbPath, { readonly: true });
-  }
-
-  async querySQLite(query, params = []) {
-    const stmt = this.sqliteClient.prepare(query);
-    return stmt.all(...params);
+    this.sqlite = new Database(dbPath, { readonly: true });
   }
 
   async initMongo(context) {
     const { MongoClient } = require("mongodb");
-    const uri =
-      context.MONGO_URI ||
-      `mongodb://localhost:27017/${context.db_name || "olang"}`;
-    this.mongoClient = new MongoClient(uri);
-    await this.mongoClient.connect();
-  }
-
-  async queryMongo(collectionName, filter = {}, projection = {}) {
-    const db = this.mongoClient.db(process.env.DB_NAME || "olang");
-    return db.collection(collectionName).find(filter, { projection }).toArray();
+    const uri = context.MONGO_URI;
+    this.mongo = new MongoClient(uri);
+    await this.mongo.connect();
   }
 
   async initPostgres(context) {
     const { Pool } = require("pg");
-    this.postgresClient = new Pool({
-      connectionString: context.POSTGRES_URL,
-    });
-  }
-
-  async queryPostgres(query, params = []) {
-    const result = await this.postgresClient.query(query, params);
-    return result.rows;
+    this.pg = new Pool({ connectionString: context.POSTGRES_URL });
   }
 
   async queryDocuments(context) {
     const table = context.db_table || "documents";
-    const contentCol = context.db_content_column || "content";
     const idCol = context.db_id_column || "id";
+    const contentCol = context.db_content_column || "content";
 
-    if (context.MONGO_URI) {
-      const rows = await this.queryMongo(table);
-      return rows.map((r) => ({
-        id: r._id?.toString(),
+    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 (context.db_path) {
-      const rows = await this.querySQLite(
-        `SELECT ${idCol}, ${contentCol} FROM ${table}`
-      );
-      return rows.map((r) => ({
+    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 (context.POSTGRES_URL) {
-      const rows = await this.queryPostgres(
+    if (this.pg) {
+      const res = await this.pg.query(
         `SELECT ${idCol}, ${contentCol} FROM ${table}`
       );
-      return rows.map((r) => ({
+      return res.rows.map(r => ({
         id: r[idCol],
         content: r[contentCol],
         source: `postgres:${table}`,
@@ -140,8 +113,8 @@ class DatabaseAdapter {
 
 async function loadAllDocuments(context) {
   const docs = [];
-  const db = new DatabaseAdapter();
 
+  const db = new DatabaseAdapter();
   try {
     await db.initialize(context);
     docs.push(...(await db.queryDocuments(context)));
@@ -152,15 +125,15 @@ async function loadAllDocuments(context) {
     : path.join(process.cwd(), "docs");
 
   if (fs.existsSync(baseDir)) {
-    const files = fs
-      .readdirSync(baseDir)
-      .filter((f) => f.endsWith(".txt") || f.endsWith(".md"));
+    const files = fs.readdirSync(baseDir).filter(f =>
+      f.endsWith(".txt") || f.endsWith(".md")
+    );
 
-    for (const f of files) {
+    for (const file of files) {
       docs.push({
-        id: f,
-        content: fs.readFileSync(path.join(baseDir, f), "utf8"),
-        source: `file:${f}`,
+        id: file,
+        content: fs.readFileSync(path.join(baseDir, file), "utf8"),
+        source: `file:${file}`,
       });
     }
   }
@@ -170,20 +143,18 @@ async function loadAllDocuments(context) {
 
 /* ---------------- HYBRID VECTOR SEARCH ---------------- */
 
-async function performHybridDocQA(query, context = {}) {
+async function performHybridDocQA(query, context) {
   const cache = loadCache();
   const embedder = new LocalEmbedding({ dimension: 384 });
 
-  const vectorStore = VectorRouter.create({
+  const store = VectorRouter.create({
     backend: context.vectorBackend || "memory",
     dimension: 384,
     ...context,
   });
 
   const documents = await loadAllDocuments(context);
-  if (!documents.length) {
-    return { text: "", meta: {} };
-  }
+  if (!documents.length) return { text: "", meta: {} };
 
   for (const doc of documents) {
     if (!cache[doc.id]) {
@@ -192,7 +163,7 @@ async function performHybridDocQA(query, context = {}) {
 
       for (let i = 0; i < chunks.length; i++) {
         const vector = await embedder.embed(chunks[i]);
-        await vectorStore.upsert({
+        await store.upsert({
           id: `${doc.id}:${i}`,
           vector,
           content: chunks[i],
@@ -205,11 +176,14 @@ async function performHybridDocQA(query, context = {}) {
   saveCache(cache);
 
   const queryVector = await embedder.embed(query);
-  const results = await vectorStore.query(queryVector, 5);
+  const results = await store.search({
+    embedding: queryVector,
+    topK: 5,
+  });
 
   return {
     text: highlightMatches(
-      results.map((r) => r.content).join("\n\n"),
+      results.map(r => r.content).join("\n\n"),
       extractKeywords(query)
     ),
     meta: { matches: results.length },
@@ -218,26 +192,23 @@ async function performHybridDocQA(query, context = {}) {
 
 /* ---------------- PGVECTOR SEARCH ---------------- */
 
-async function performPgVectorSearch(query, context = {}) {
-  const adapter = new PgVectorAdapter({
-    POSTGRES_URL: context.POSTGRES_URL,
-  });
-
+async function performPgVectorSearch(query, context) {
+  const adapter = new PgVectorAdapter({ POSTGRES_URL: context.POSTGRES_URL });
   const embedder = new LocalEmbedding({ dimension: 384 });
-  const vector = await embedder.embed(query);
-  const results = await adapter.query(vector, 5);
 
+  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"),
+    text: results.map(r => r.content).join("\n\n"),
     meta: { matches: results.length },
   };
 }
 
 /* ---------------- ROUTER ---------------- */
 
-async function performDocQA(query, context = {}) {
+async function performDocQA(query, context) {
   if (context.POSTGRES_URL) {
     return performPgVectorSearch(query, context);
   }
@@ -247,15 +218,16 @@ async function performDocQA(query, context = {}) {
 /* ---------------- O-LANG RESOLVER ---------------- */
 
 async function docSearchResolver(action, context) {
-  if (action.startsWith("Ask doc-search")) {
-    const match = action.match(/"(.*)"|'(.*)'/);
-    const query = match
-      ? match[1] || match[2]
-      : action.replace("Ask doc-search", "").trim();
+  if (!action.startsWith("Ask doc-search")) return;
 
-    return performDocQA(query, context);
-  }
+  const match = action.match(/"(.*)"|'(.*)'/);
+  const query = match
+    ? match[1] || match[2]
+    : action.replace("Ask doc-search", "").trim();
+
+  return performDocQA(query, context);
 }
 
 docSearchResolver.resolverName = "doc-search";
 module.exports = docSearchResolver;
+