mumpix 1.0.20 → 1.0.29

package/src/core/wal-writer.js

@@ -0,0 +1,83 @@
+"use strict";
+
+const fs = require("fs");
+
+class WalWriter {
+  constructor(walPath, tier, opts = {}) {
+    this._walPath = walPath;
+    this._perRecord = tier === "strict" || tier === "verified";
+    this._intervalMs = Number.isFinite(opts.intervalMs) ? opts.intervalMs : 10;
+    this._maxPending = Number.isFinite(opts.maxPendingBytes)
+      ? opts.maxPendingBytes
+      : 1024 * 1024;
+    this._fd = null;
+    this._pendingBytes = 0;
+    this._lastFlush = 0;
+  }
+
+  _ensureFd() {
+    if (this._fd == null) {
+      this._fd = fs.openSync(this._walPath, "a");
+    }
+  }
+
+  append(line) {
+    this._ensureFd();
+    const buf = line.endsWith("\n") ? line : `${line}\n`;
+    fs.writeSync(this._fd, buf, null, "utf8");
+
+    if (this._perRecord) {
+      fs.fdatasyncSync(this._fd);
+      return;
+    }
+
+    this._pendingBytes += Buffer.byteLength(buf);
+    const now = Date.now();
+    if (
+      this._pendingBytes >= this._maxPending ||
+      now - this._lastFlush >= this._intervalMs
+    ) {
+      this.flush();
+    }
+  }
+
+  appendBatch(lines) {
+    if (!lines.length) return;
+    this._ensureFd();
+    const joined = `${lines.join("\n")}\n`;
+    fs.writeSync(this._fd, joined, null, "utf8");
+    this.flush();
+  }
+
+  flush() {
+    if (this._fd == null) return;
+    fs.fdatasyncSync(this._fd);
+    this._pendingBytes = 0;
+    this._lastFlush = Date.now();
+  }
+
+  close({ flush = true } = {}) {
+    if (this._fd == null) return;
+    if (flush) {
+      try {
+        fs.fdatasyncSync(this._fd);
+      } catch (_) {
+        // Best effort on shutdown.
+      }
+    }
+    try {
+      fs.closeSync(this._fd);
+    } catch (_) {}
+    this._fd = null;
+    this._pendingBytes = 0;
+  }
+
+  unlink({ flush = this._perRecord } = {}) {
+    this.close({ flush });
+    try {
+      fs.unlinkSync(this._walPath);
+    } catch (_) {}
+  }
+}
+
+module.exports = { WalWriter };

package/src/index.js

@@ -1,51 +1,37 @@
-'use strict';
+"use strict";
+
+const { MumpixDB } = require("./core/MumpixDB");
+const { MumpixStore } = require("./core/store");
+const { MumpixAudit } = require("./core/audit");
+const { WalWriter } = require("./core/wal-writer");
+const { InvertedIndex } = require("./core/inverted-index");
+const { recall, recallMany, tokenize } = require("./core/recall");
+const { MumpixDevClient, MumpixApiError } = require("./integrations/developer-sdk");
+const temporal = require("./temporal/operators");
+const temporalEngine = require("./temporal/engine");
+const temporalIndexes = require("./temporal/indexes");
+const brp = require("./brp");
+const rlp = require("./rlp");
+const collapse = require("./collapse");
 
-/**
- * mumpix — SQLite for AI
- *
- * Quick start:
- *   const { Mumpix } = require('mumpix')
- *   const db = Mumpix.open('./agent.mumpix', { consistency: 'strict' })
- *
- *   await db.remember('User prefers TypeScript')
- *   const ans = await db.recall('What language do they prefer?')
- *   console.log(ans) // → 'User prefers TypeScript'
- *
- *   await db.close()
- */
-
-const { MumpixDB }    = require('./core/MumpixDB');
-const { MumpixStore } = require('./core/store');
-const { MumpixAudit } = require('./core/audit');
-const { recall, recallMany, tokenize } = require('./core/recall');
-const { MumpixDevClient, MumpixApiError } = require('./integrations/developer-sdk');
-const temporal = require('./temporal/operators');
-const temporalEngine = require('./temporal/engine');
-const temporalIndexes = require('./temporal/indexes');
-
-// Convenience alias: Mumpix.open() === MumpixDB.open()
 const Mumpix = MumpixDB;
 
 module.exports = {
-  // Primary export — use this
   Mumpix,
   MumpixDB,
-
-  // Lower-level exports for advanced use
   MumpixStore,
   MumpixAudit,
-
-  // Recall utilities — useful for custom pipelines
+  WalWriter,
+  InvertedIndex,
   recall,
   recallMany,
   tokenize,
-
-  // Deterministic temporal event operators
   temporal,
   temporalEngine,
   temporalIndexes,
-
-  // Developer SDK (HTTP client for Mumpix services)
+  brp,
+  rlp,
+  collapse,
   MumpixDevClient,
   MumpixApiError,
 };

package/src/integrations/developer-sdk.js

@@ -1,165 +1 @@
-'use strict';
-
-class MumpixApiError extends Error {
-  constructor(message, status, data) {
-    super(message);
-    this.name = 'MumpixApiError';
-    this.status = status;
-    this.data = data;
-  }
-}
-
-class MumpixDevClient {
-  constructor(opts = {}) {
-    const baseUrl = String(opts.baseUrl || 'http://127.0.0.1:3012').replace(/\/+$/, '');
-    this.baseUrl = baseUrl;
-    this.fetch = opts.fetch || globalThis.fetch;
-    this.defaultHeaders = opts.headers && typeof opts.headers === 'object' ? { ...opts.headers } : {};
-    if (typeof this.fetch !== 'function') {
-      throw new Error('MumpixDevClient requires fetch (Node 18+ or pass opts.fetch)');
-    }
-  }
-
-  _url(path, query) {
-    const cleanPath = String(path || '').startsWith('/') ? String(path) : `/${String(path || '')}`;
-    const url = new URL(this.baseUrl + cleanPath);
-    if (query && typeof query === 'object') {
-      for (const [key, value] of Object.entries(query)) {
-        if (value === undefined || value === null || value === '') continue;
-        url.searchParams.set(key, String(value));
-      }
-    }
-    return url.toString();
-  }
-
-  async _request(path, opts = {}) {
-    const method = String(opts.method || 'GET').toUpperCase();
-    const headers = { ...this.defaultHeaders, ...(opts.headers || {}) };
-    let body = opts.body;
-    if (body && typeof body === 'object' && !(body instanceof ArrayBuffer) && !(body instanceof Uint8Array) && !(typeof FormData !== 'undefined' && body instanceof FormData)) {
-      headers['Content-Type'] = headers['Content-Type'] || 'application/json; charset=utf-8';
-      body = JSON.stringify(body);
-    }
-
-    const res = await this.fetch(this._url(path, opts.query), {
-      method,
-      headers,
-      body,
-      credentials: opts.credentials || 'include',
-      signal: opts.signal,
-    });
-
-    const contentType = String(res.headers.get('content-type') || '').toLowerCase();
-    let data;
-    if (contentType.includes('application/json')) {
-      data = await res.json().catch(() => null);
-    } else {
-      data = await res.text().catch(() => '');
-    }
-
-    if (!res.ok) {
-      const msg = data && typeof data === 'object' && data.error
-        ? String(data.error)
-        : `Request failed (${res.status})`;
-      throw new MumpixApiError(msg, res.status, data);
-    }
-    return data;
-  }
-
-  health() {
-    return this._request('/api/health');
-  }
-
-  async remember(content) {
-    // Primary app API expects `text`. Keep `content` fallback for older endpoints.
-    try {
-      return await this._request('/remember', { method: 'POST', body: { text: content } });
-    } catch (error) {
-      if (error && Number(error.status) === 400) {
-        return this._request('/remember', { method: 'POST', body: { content } });
-      }
-      throw error;
-    }
-  }
-
-  recall(query) {
-    return this._request('/recall', { method: 'POST', body: { query } });
-  }
-
-  recallMany(query, k = 5) {
-    return this._request('/recall-many', { method: 'POST', body: { query, k } });
-  }
-
-  memories() {
-    return this._request('/memories');
-  }
-
-  clear() {
-    return this._request('/memories', { method: 'DELETE' });
-  }
-
-  stats() {
-    return this._request('/stats');
-  }
-
-  settings() {
-    return this._request('/settings');
-  }
-
-  updateSettings(patch) {
-    return this._request('/settings', { method: 'POST', body: patch || {} });
-  }
-
-  files() {
-    return this._request('/mumpix-explorer/files');
-  }
-
-  readFile(file, opts = {}) {
-    return this._request('/mumpix-explorer/read', {
-      query: {
-        file,
-        atTs: opts.atTs,
-        source: opts.source,
-      },
-    });
-  }
-
-  timeline(file, opts = {}) {
-    return this._request('/mumpix-explorer/timeline', {
-      query: {
-        file,
-        source: opts.source,
-      },
-    });
-  }
-
-  exportUrl(file, format = 'mumpix', opts = {}) {
-    return this._url('/mumpix-explorer/export', {
-      file,
-      format,
-      atTs: opts.atTs,
-      source: opts.source,
-    });
-  }
-
-  roms() {
-    return this._request('/emulator/roms');
-  }
-
-  manualForRom(file) {
-    return this._request('/emulator/manual', { query: { file } });
-  }
-
-  manualViewUrl(file, opts = {}) {
-    return this._url('/emulator/manual/view', {
-      file,
-      isolate: opts.isolate ? '1' : undefined,
-      v: opts.v || Date.now(),
-    });
-  }
-}
-
-module.exports = {
-  MumpixDevClient,
-  MumpixApiError,
-};
+"use strict";class e extends Error{constructor(e,t,r){super(e),this.name="MumpixApiError",this.status=t,this.data=r}}module.exports={MumpixDevClient:class{constructor(e={}){const t=String(e.baseUrl||"http://127.0.0.1:3012").replace(/\/+$/,"");if(this.baseUrl=t,this.fetch=e.fetch||globalThis.fetch,this.defaultHeaders=e.headers&&"object"==typeof e.headers?{...e.headers}:{},"function"!=typeof this.fetch)throw new Error("MumpixDevClient requires fetch (Node 18+ or pass opts.fetch)")}_url(e,t){const r=String(e||"").startsWith("/")?String(e):`/${String(e||"")}`,s=new URL(this.baseUrl+r);if(t&&"object"==typeof t)for(const[e,r]of Object.entries(t))null!=r&&""!==r&&s.searchParams.set(e,String(r));return s.toString()}async _request(t,r={}){const s=String(r.method||"GET").toUpperCase(),i={...this.defaultHeaders,...r.headers||{}};let o=r.body;!o||"object"!=typeof o||o instanceof ArrayBuffer||o instanceof Uint8Array||"undefined"!=typeof FormData&&o instanceof FormData||(i["Content-Type"]=i["Content-Type"]||"application/json; charset=utf-8",o=JSON.stringify(o));const a=await this.fetch(this._url(t,r.query),{method:s,headers:i,body:o,credentials:r.credentials||"include",signal:r.signal});let n;if(n=String(a.headers.get("content-type")||"").toLowerCase().includes("application/json")?await a.json().catch(()=>null):await a.text().catch(()=>""),!a.ok){const t=n&&"object"==typeof n&&n.error?String(n.error):`Request failed (${a.status})`;throw new e(t,a.status,n)}return n}health(){return this._request("/api/health")}async remember(e){try{return await this._request("/remember",{method:"POST",body:{text:e}})}catch(t){if(t&&400===Number(t.status))return this._request("/remember",{method:"POST",body:{content:e}});throw t}}recall(e){return this._request("/recall",{method:"POST",body:{query:e}})}recallMany(e,t=5){return this._request("/recall-many",{method:"POST",body:{query:e,k:t}})}memories(){return this._request("/memories")}clear(){return this._request("/memories",{method:"DELETE"})}stats(){return this._request("/stats")}settings(){return this._request("/settings")}updateSettings(e){return this._request("/settings",{method:"POST",body:e||{}})}files(){return this._request("/mumpix-explorer/files")}readFile(e,t={}){return this._request("/mumpix-explorer/read",{query:{file:e,atTs:t.atTs,source:t.source}})}timeline(e,t={}){return this._request("/mumpix-explorer/timeline",{query:{file:e,source:t.source}})}exportUrl(e,t="mumpix",r={}){return this._url("/mumpix-explorer/export",{file:e,format:t,atTs:r.atTs,source:r.source})}roms(){return this._request("/emulator/roms")}manualForRom(e){return this._request("/emulator/manual",{query:{file:e}})}manualViewUrl(e,t={}){return this._url("/emulator/manual/view",{file:e,isolate:t.isolate?"1":void 0,v:t.v||Date.now()})}},MumpixApiError:e};

package/src/integrations/langchain-official.js

@@ -0,0 +1 @@
+"use strict";let e;try{e={...require("@langchain/core/vectorstores"),...require("@langchain/core/retrievers"),...require("@langchain/core/documents"),...require("@langchain/core/memory")}}catch(e){throw new Error("mumpix LangChain official adapters require optional peer dependency @langchain/core. Install it with: npm i @langchain/core")}const{VectorStore:t,BaseRetriever:r,Document:i,BaseMemory:a}=e,{MumpixVectorSidecar:s}=require("./vector-sidecar");function n(e){if(!e||"function"!=typeof e.embedDocuments||"function"!=typeof e.embedQuery)throw new Error("MumpixLangChainVectorStore requires a LangChain embeddings object for this operation.")}function c(e){return e&&"string"==typeof e.pageContent?e.pageContent:String(e||"")}function o(e){return e&&e.metadata&&"object"==typeof e.metadata?e.metadata:{}}function d(e){return new i({pageContent:e.text,metadata:{...e.metadata,id:e.id,score:e.score}})}module.exports={MumpixLangChainVectorStore:class extends t{constructor(e,t={}){super(t.embeddings||{},t),this.db=e,this.sidecar=new s(e,t)}_vectorstoreType(){return"mumpix"}async addDocuments(e,t={}){n(this.embeddings);const r=await this.embeddings.embedDocuments(e.map(c));return this.addVectors(r,e,t)}async addVectors(e,t){const r=[];for(let i=0;i<t.length;i++){const a=t[i],s=o(a),n=await this.sidecar.addItem({id:s.id||s.textId,text:c(a),embedding:e[i],metadata:s,refDocId:s.refDocId||s.source});r.push(n)}return r}async addTexts(e,t=[]){const r=e.map((e,r)=>new i({pageContent:e,metadata:Array.isArray(t)?t[r]||{}:t||{}}));return this.addDocuments(r)}async delete(e={}){const t=e.ids||e.id;if(Array.isArray(t))for(const e of t)this.sidecar.deleteRefDoc(e);else t?this.sidecar.deleteRefDoc(t):e.refDocId&&this.sidecar.deleteRefDoc(e.refDocId)}async similaritySearchVectorWithScore(e,t,r){return this.sidecar.query(e,t,{filters:r}).records.map(e=>[d(e),e.score])}async similaritySearch(e,t=4,r){n(this.embeddings);const i=await this.embeddings.embedQuery(String(e||""));return this.sidecar.query(i,t,{filters:r}).records.map(d)}async similaritySearchWithScore(e,t=4,r){n(this.embeddings);const i=await this.embeddings.embedQuery(String(e||""));return this.sidecar.query(i,t,{filters:r}).records.map(e=>[d(e),e.score])}async maxMarginalRelevanceSearch(e,t={}){n(this.embeddings);const r=await this.embeddings.embedQuery(String(e||""));return this.sidecar.query(r,t.k||4,{filters:t.filter,mode:"mmr",lambda:t.lambda}).records.map(d)}async save(){this.sidecar.persist()}},MumpixLangChainRetriever:class extends r{constructor(e,t={}){super(t),this.db=e,this.k=t.k||4,this.lc_namespace=["mumpix","retrievers"]}async _getRelevantDocuments(e){return(await this.db.recallMany(String(e||""),this.k)).map(e=>new i({pageContent:e.content,metadata:{id:e.id,ts:e.ts,score:e.score}}))}},MumpixLangChainMemory:class extends a{constructor({db:e,k:t=4,inputKey:r="input",outputKey:i="output",memoryKey:a="history"}={}){super(),this.db=e,this.k=t,this.inputKey=r,this.outputKey=i,this.memoryKey=a}get memoryKeys(){return[this.memoryKey]}async loadMemoryVariables(e){const t=e[this.inputKey]||"",r=await this.db.recallMany(String(t),this.k);return{[this.memoryKey]:r.map(e=>e.content).join("\n")}}async saveContext(e,t){const r=e[this.inputKey]||"",i=t[this.outputKey]||"";r&&await this.db.remember(`Human: ${r}`),i&&await this.db.remember(`AI: ${i}`)}async clear(){await this.db.clear()}}};

package/src/integrations/langchain.js

@@ -1,131 +1 @@
-'use strict';
-
-/**
- * Mumpix × LangChain integration
- *
- * Usage:
- *   const { MumpixVectorStore } = require('mumpix/src/integrations/langchain')
- *   const db = Mumpix.open('./agent.mumpix', { consistency: 'strict' })
- *   const store = new MumpixVectorStore(db)
- *
- *   // Use as a LangChain Memory:
- *   const memory = new MumpixChatMemory({ db })
- */
-
-const { recallMany } = require('../core/recall');
-
-/**
- * MumpixVectorStore — drop-in VectorStore adapter for LangChain.
- *
- * Works with any LangChain retriever that accepts .similaritySearch().
- * No external vector library required — uses Mumpix's built-in TF-IDF.
- */
-class MumpixVectorStore {
-  constructor(db) {
-    this.db = db;
-  }
-
-  /**
-   * LangChain VectorStore interface
-   */
-  async similaritySearch(query, k = 4) {
-    const results = await this.db.recallMany(query, k);
-    return results.map(r => ({
-      pageContent: r.content,
-      metadata: { id: r.id, ts: r.ts, score: r.score },
-    }));
-  }
-
-  async similaritySearchWithScore(query, k = 4) {
-    const results = await this.db.recallMany(query, k);
-    return results.map(r => ([
-      { pageContent: r.content, metadata: { id: r.id, ts: r.ts } },
-      r.score,
-    ]));
-  }
-
-  async addDocuments(docs) {
-    const results = [];
-    for (const doc of docs) {
-      const r = await this.db.remember(doc.pageContent);
-      results.push(r.id.toString());
-    }
-    return results;
-  }
-
-  async addTexts(texts, metadatas = []) {
-    const ids = [];
-    for (const text of texts) {
-      const r = await this.db.remember(text);
-      ids.push(r.id.toString());
-    }
-    return ids;
-  }
-}
-
-/**
- * MumpixChatMemory — LangChain BaseChatMemory compatible adapter.
- *
- * Stores conversation turns as memories and retrieves them semantically.
- *
- * const memory = new MumpixChatMemory({ db, k: 3 })
- * // Then pass as `memory` to LLMChain, ConversationChain, etc.
- */
-class MumpixChatMemory {
-  constructor({ db, k = 4, inputKey = 'input', outputKey = 'output' } = {}) {
-    this.db        = db;
-    this.k         = k;
-    this.inputKey  = inputKey;
-    this.outputKey = outputKey;
-    this.memoryKey = 'history';
-  }
-
-  get memoryKeys() {
-    return [this.memoryKey];
-  }
-
-  async loadMemoryVariables(values) {
-    const query   = values[this.inputKey] || '';
-    const results = await this.db.recallMany(query, this.k);
-    const history = results.map(r => r.content).join('\n');
-    return { [this.memoryKey]: history };
-  }
-
-  async saveContext(inputs, outputs) {
-    const input  = inputs[this.inputKey]   || '';
-    const output = outputs[this.outputKey] || '';
-    if (input)  await this.db.remember(`Human: ${input}`);
-    if (output) await this.db.remember(`AI: ${output}`);
-  }
-
-  async clear() {
-    await this.db.clear();
-  }
-}
-
-/**
- * MumpixRetriever — LangChain BaseRetriever compatible adapter.
- *
- * const retriever = new MumpixRetriever(db, { k: 5 })
- * const results = await retriever.getRelevantDocuments("query")
- */
-class MumpixRetriever {
-  constructor(db, opts = {}) {
-    this.db = db;
-    this.k  = opts.k || 4;
-  }
-
-  async getRelevantDocuments(query) {
-    const results = await this.db.recallMany(query, this.k);
-    return results.map(r => ({
-      pageContent: r.content,
-      metadata: { id: r.id, ts: r.ts, score: r.score },
-    }));
-  }
-}
-
-module.exports = {
-  MumpixVectorStore,
-  MumpixChatMemory,
-  MumpixRetriever,
-};
+"use strict";const{recallMany:t}=require("../core/recall");module.exports={MumpixVectorStore:class{constructor(t){this.db=t}async similaritySearch(t,e=4){return(await this.db.recallMany(t,e)).map(t=>({pageContent:t.content,metadata:{id:t.id,ts:t.ts,score:t.score}}))}async similaritySearchWithScore(t,e=4){return(await this.db.recallMany(t,e)).map(t=>[{pageContent:t.content,metadata:{id:t.id,ts:t.ts}},t.score])}async addDocuments(t){const e=[];for(const s of t){const t=await this.db.remember(s.pageContent);e.push(t.id.toString())}return e}async addTexts(t,e=[]){const s=[];for(const e of t){const t=await this.db.remember(e);s.push(t.id.toString())}return s}},MumpixChatMemory:class{constructor({db:t,k:e=4,inputKey:s="input",outputKey:a="output"}={}){this.db=t,this.k=e,this.inputKey=s,this.outputKey=a,this.memoryKey="history"}get memoryKeys(){return[this.memoryKey]}async loadMemoryVariables(t){const e=t[this.inputKey]||"",s=(await this.db.recallMany(e,this.k)).map(t=>t.content).join("\n");return{[this.memoryKey]:s}}async saveContext(t,e){const s=t[this.inputKey]||"",a=e[this.outputKey]||"";s&&await this.db.remember(`Human: ${s}`),a&&await this.db.remember(`AI: ${a}`)}async clear(){await this.db.clear()}},MumpixRetriever:class{constructor(t,e={}){this.db=t,this.k=e.k||4}async getRelevantDocuments(t){return(await this.db.recallMany(t,this.k)).map(t=>({pageContent:t.content,metadata:{id:t.id,ts:t.ts,score:t.score}}))}}};

package/src/integrations/llamaindex-official.js

@@ -0,0 +1 @@
+"use strict";let e,t;try{e=require("llamaindex"),t=require("llamaindex/vector-store")}catch(e){throw new Error("mumpix LlamaIndex official adapters require optional peer dependency llamaindex. Install it with: npm i llamaindex")}const{BaseRetriever:r,TextNode:i}=e,{BaseVectorStore:n,VectorStoreQueryMode:d}=t,{MumpixVectorSidecar:a}=require("./vector-sidecar"),s={getTextEmbedding:async()=>[],getQueryEmbedding:async()=>[]};function o(e){return e&&"function"==typeof e.getContent?String(e.getContent()||""):e&&"string"==typeof e.text?e.text:e&&"function"==typeof e.getText?String(e.getText()||""):String(e||"")}function c(e){if(e&&"function"==typeof e.getEmbedding)return e.getEmbedding();if(e&&Array.isArray(e.embedding))return e.embedding;throw new Error("MumpixLlamaIndexVectorStore.add() requires nodes with embeddings.")}function u(e){return e&&e.metadata&&"object"==typeof e.metadata?e.metadata:{}}function m(e){return e&&e.sourceNode&&(e.sourceNode.nodeId||e.sourceNode.id_)||e&&e.refDocId||e&&e.id_||null}function l(e){return new i({id_:String(e.id),text:e.text,metadata:e.metadata||{}})}module.exports={MumpixLlamaIndexVectorStore:class extends n{constructor(e,t={}){super({...t,embedModel:t.embedModel||t.embeddingModel||s}),this.db=e,this.storesText=!0,this.sidecar=new a(e,t)}client(){return null}async get(e){return this.sidecar.get(e)}async add(e){const t=[];for(const r of e){const e=await this.sidecar.addItem({id:r&&r.id_,text:o(r),embedding:c(r),metadata:u(r),refDocId:m(r)});t.push(e)}return t}async delete(e){this.sidecar.deleteRefDoc(e)}async query(e){if(!e||!Array.isArray(e.queryEmbedding))throw new Error("MumpixLlamaIndexVectorStore.query() requires query.queryEmbedding.");const t=e.mode===d.MMR?"mmr":"default",r=this.sidecar.query(e.queryEmbedding,e.similarityTopK||5,{mode:t,filters:e.filters,docIds:e.docIds,lambda:e.alpha});return{ids:r.ids,similarities:r.similarities,nodes:r.records.map(l)}}async persist(e){e&&(this.sidecar.vectorPath=e),this.sidecar.persist()}},MumpixLlamaIndexRetriever:class extends r{constructor(e,t={}){super(),this.db=e,this.topK=t.topK||5}async _retrieve(e){const t=function(e){return"string"==typeof e?e:e&&"string"==typeof e.query?e.query:e&&"string"==typeof e.queryStr?e.queryStr:String(e&&e.query?e.query:"")}(e);return(await this.db.recallMany(t,this.topK)).map(e=>({node:new i({id_:String(e.id),text:e.content,metadata:{ts:e.ts}}),score:e.score}))}}};

package/src/integrations/llamaindex.js

@@ -1,86 +1 @@
-'use strict';
-
-/**
- * Mumpix × LlamaIndex integration
- *
- * Usage:
- *   const { MumpixReader, MumpixIndex } = require('mumpix/src/integrations/llamaindex')
- *   const db = Mumpix.open('./agent.mumpix', { consistency: 'strict' })
- *   const index = new MumpixIndex(db)
- *   const retriever = index.asRetriever({ topK: 5 })
- */
-
-/**
- * MumpixIndex — wraps a MumpixDB as a LlamaIndex-style index.
- */
-class MumpixIndex {
-  constructor(db) {
-    this.db = db;
-  }
-
-  asRetriever(opts = {}) {
-    return new MumpixIndexRetriever(this.db, opts);
-  }
-
-  /**
-   * Insert a document / text node.
-   */
-  async insert(node) {
-    const text = typeof node === 'string' ? node : (node.text || node.content || '');
-    return this.db.remember(text);
-  }
-
-  async insertMany(nodes) {
-    const results = [];
-    for (const n of nodes) results.push(await this.insert(n));
-    return results;
-  }
-}
-
-/**
- * MumpixIndexRetriever — LlamaIndex-compatible retriever.
- */
-class MumpixIndexRetriever {
-  constructor(db, opts = {}) {
-    this.db   = db;
-    this.topK = opts.topK || 5;
-  }
-
-  async retrieve(queryBundle) {
-    const query   = typeof queryBundle === 'string' ? queryBundle : queryBundle.queryStr;
-    const results = await this.db.recallMany(query, this.topK);
-    return results.map(r => ({
-      node: {
-        id_:       r.id.toString(),
-        text:      r.content,
-        metadata:  { ts: r.ts },
-        getContent: () => r.content,
-      },
-      score: r.score,
-    }));
-  }
-}
-
-/**
- * MumpixReader — load .mumpix file contents as LlamaIndex documents.
- */
-class MumpixReader {
-  constructor(db) {
-    this.db = db;
-  }
-
-  async loadData() {
-    const memories = await this.db.list();
-    return memories.map(m => ({
-      id_:      m.id.toString(),
-      text:     m.content,
-      metadata: { source: 'mumpix', ts: m.ts },
-    }));
-  }
-}
-
-module.exports = {
-  MumpixIndex,
-  MumpixIndexRetriever,
-  MumpixReader,
-};
+"use strict";class t{constructor(t,e={}){this.db=t,this.topK=e.topK||5}async retrieve(t){const e="string"==typeof t?t:t.queryStr;return(await this.db.recallMany(e,this.topK)).map(t=>({node:{id_:t.id.toString(),text:t.content,metadata:{ts:t.ts},getContent:()=>t.content},score:t.score}))}}module.exports={MumpixIndex:class{constructor(t){this.db=t}asRetriever(e={}){return new t(this.db,e)}async insert(t){const e="string"==typeof t?t:t.text||t.content||"";return this.db.remember(e)}async insertMany(t){const e=[];for(const s of t)e.push(await this.insert(s));return e}},MumpixIndexRetriever:t,MumpixReader:class{constructor(t){this.db=t}async loadData(){return(await this.db.list()).map(t=>({id_:t.id.toString(),text:t.content,metadata:{source:"mumpix",ts:t.ts}}))}}};