@forbocai/node 0.4.4

package/dist/index.d.mts

@@ -0,0 +1,107 @@
+import { CortexConfig, ICortex, MemoryType, MemoryItem, MemoryConfig } from '@forbocai/core';
+
+declare const createCortex: (config: CortexConfig) => ICortex & {
+    embed: (text: string) => Promise<number[]>;
+};
+
+/**
+ * Interface definition for Memory operations.
+ */
+interface IMemory {
+    /**
+     * Stores a text memory.
+     * @param text - The content of the memory.
+     * @param type - The type of memory (e.g., 'observation').
+     * @param importance - The importance score (0-1).
+     * @returns A promise resolving to the stored MemoryItem.
+     */
+    store(text: string, type?: MemoryType, importance?: number): Promise<MemoryItem>;
+    /**
+     * Recalls memories relevant to a query.
+     * @param query - The query string.
+     * @param limit - Maximum number of memories to return.
+     * @returns A promise resolving to an array of relevant MemoryItems.
+     */
+    recall(query: string, limit?: number): Promise<MemoryItem[]>;
+    /**
+     * Lists recent memories.
+     * @param limit - Maximum number of memories to list.
+     * @param offset - Offset for pagination.
+     * @returns A promise resolving to an array of MemoryItems.
+     */
+    list(limit?: number, offset?: number): Promise<MemoryItem[]>;
+    /**
+     * Exports all memories (for Soul portability/backup).
+     * @returns A promise resolving to an array of all MemoryItems.
+     */
+    export(): Promise<MemoryItem[]>;
+    /**
+     * Imports memories (for Soul hydration/restore).
+     * @param memories - Array of MemoryItems to import.
+     */
+    import(memories: MemoryItem[]): Promise<void>;
+    /**
+     * Clears all stored memories.
+     */
+    clear(): Promise<void>;
+}
+/**
+ * Configuration for the Memory module.
+ */
+interface MemoryModuleConfig extends MemoryConfig {
+    /** Key to use for storage/table name. */
+    storageKey?: string;
+    /** Optional API URL for remote operations. */
+    apiUrl?: string;
+    /** ID of the agent owning this memory. */
+    agentId?: string;
+}
+/**
+ * Helper to create a standard MemoryItem object.
+ * @param text - The memory content.
+ * @param type - The type of memory.
+ * @param importance - Importance score (0-1).
+ * @returns A formatted MemoryItem.
+ */
+declare const createMemoryItem: (text: string, type?: MemoryType, importance?: number) => MemoryItem;
+/**
+ * Factory function to create a Memory module instance (LanceDB backed).
+ * @param config - Configuration for the memory module.
+ * @returns An instance of IMemory.
+ */
+declare const createMemory: (config?: MemoryModuleConfig) => IMemory;
+
+/**
+ * Status of the Vector Engine.
+ */
+interface VectorStatus {
+    ready: boolean;
+    backend: 'lancedb' | 'memory';
+}
+/**
+ * Initializes the vector engine (Transformers + LanceDB).
+ */
+declare const initVectorEngine: () => Promise<void>;
+/**
+ * Generates an embedding vector for the given text.
+ * @param text - The text to embed.
+ * @returns A promise resolving to the embedding vector (number array).
+ */
+declare const generateEmbedding: (text: string) => Promise<number[]>;
+/**
+ * Retrieves or creates a table in LanceDB.
+ * @param dbPath - Path to the LanceDB directory.
+ * @param tableName - Name of the table.
+ * @returns The table object or null if not found/created.
+ */
+declare const getVectorTable: (dbPath: string, tableName?: string) => Promise<any>;
+/**
+ * Creates a new table in LanceDB.
+ * @param dbPath - Path to the LanceDB directory.
+ * @param tableName - Name of the table.
+ * @param data - Initial data to populate the table.
+ * @returns The created table object.
+ */
+declare const createTable: (dbPath: string, tableName: string, data: any[]) => Promise<any>;
+
+export { type IMemory, type MemoryModuleConfig, type VectorStatus, createCortex, createMemory, createMemoryItem, createTable, generateEmbedding, getVectorTable, initVectorEngine };

package/dist/index.d.ts

@@ -0,0 +1,107 @@
+import { CortexConfig, ICortex, MemoryType, MemoryItem, MemoryConfig } from '@forbocai/core';
+
+declare const createCortex: (config: CortexConfig) => ICortex & {
+    embed: (text: string) => Promise<number[]>;
+};
+
+/**
+ * Interface definition for Memory operations.
+ */
+interface IMemory {
+    /**
+     * Stores a text memory.
+     * @param text - The content of the memory.
+     * @param type - The type of memory (e.g., 'observation').
+     * @param importance - The importance score (0-1).
+     * @returns A promise resolving to the stored MemoryItem.
+     */
+    store(text: string, type?: MemoryType, importance?: number): Promise<MemoryItem>;
+    /**
+     * Recalls memories relevant to a query.
+     * @param query - The query string.
+     * @param limit - Maximum number of memories to return.
+     * @returns A promise resolving to an array of relevant MemoryItems.
+     */
+    recall(query: string, limit?: number): Promise<MemoryItem[]>;
+    /**
+     * Lists recent memories.
+     * @param limit - Maximum number of memories to list.
+     * @param offset - Offset for pagination.
+     * @returns A promise resolving to an array of MemoryItems.
+     */
+    list(limit?: number, offset?: number): Promise<MemoryItem[]>;
+    /**
+     * Exports all memories (for Soul portability/backup).
+     * @returns A promise resolving to an array of all MemoryItems.
+     */
+    export(): Promise<MemoryItem[]>;
+    /**
+     * Imports memories (for Soul hydration/restore).
+     * @param memories - Array of MemoryItems to import.
+     */
+    import(memories: MemoryItem[]): Promise<void>;
+    /**
+     * Clears all stored memories.
+     */
+    clear(): Promise<void>;
+}
+/**
+ * Configuration for the Memory module.
+ */
+interface MemoryModuleConfig extends MemoryConfig {
+    /** Key to use for storage/table name. */
+    storageKey?: string;
+    /** Optional API URL for remote operations. */
+    apiUrl?: string;
+    /** ID of the agent owning this memory. */
+    agentId?: string;
+}
+/**
+ * Helper to create a standard MemoryItem object.
+ * @param text - The memory content.
+ * @param type - The type of memory.
+ * @param importance - Importance score (0-1).
+ * @returns A formatted MemoryItem.
+ */
+declare const createMemoryItem: (text: string, type?: MemoryType, importance?: number) => MemoryItem;
+/**
+ * Factory function to create a Memory module instance (LanceDB backed).
+ * @param config - Configuration for the memory module.
+ * @returns An instance of IMemory.
+ */
+declare const createMemory: (config?: MemoryModuleConfig) => IMemory;
+
+/**
+ * Status of the Vector Engine.
+ */
+interface VectorStatus {
+    ready: boolean;
+    backend: 'lancedb' | 'memory';
+}
+/**
+ * Initializes the vector engine (Transformers + LanceDB).
+ */
+declare const initVectorEngine: () => Promise<void>;
+/**
+ * Generates an embedding vector for the given text.
+ * @param text - The text to embed.
+ * @returns A promise resolving to the embedding vector (number array).
+ */
+declare const generateEmbedding: (text: string) => Promise<number[]>;
+/**
+ * Retrieves or creates a table in LanceDB.
+ * @param dbPath - Path to the LanceDB directory.
+ * @param tableName - Name of the table.
+ * @returns The table object or null if not found/created.
+ */
+declare const getVectorTable: (dbPath: string, tableName?: string) => Promise<any>;
+/**
+ * Creates a new table in LanceDB.
+ * @param dbPath - Path to the LanceDB directory.
+ * @param tableName - Name of the table.
+ * @param data - Initial data to populate the table.
+ * @returns The created table object.
+ */
+declare const createTable: (dbPath: string, tableName: string, data: any[]) => Promise<any>;
+
+export { type IMemory, type MemoryModuleConfig, type VectorStatus, createCortex, createMemory, createMemoryItem, createTable, generateEmbedding, getVectorTable, initVectorEngine };

package/dist/index.js

@@ -0,0 +1,380 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  createCortex: () => createCortex,
+  createMemory: () => createMemory,
+  createMemoryItem: () => createMemoryItem,
+  createTable: () => createTable,
+  generateEmbedding: () => generateEmbedding,
+  getVectorTable: () => getVectorTable,
+  initVectorEngine: () => initVectorEngine
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/cortex.ts
+var fs = __toESM(require("fs"));
+var path = __toESM(require("path"));
+var https = __toESM(require("https"));
+var isNode = typeof process !== "undefined" && process.versions != null && process.versions.node != null;
+if (!isNode) {
+  throw new Error("ForbocAI SDK requires Node.js environment - browser support has been removed");
+}
+var MODEL_URLS = {
+  "smollm2-135m": "https://huggingface.co/bartowski/SmolLM2-135M-Instruct-GGUF/resolve/main/SmolLM2-135M-Instruct-Q4_K_M.gguf",
+  "llama3-8b": "https://huggingface.co/lmstudio-community/Meta-Llama-3-8B-Instruct-GGUF/resolve/main/Meta-Llama-3-8B-Instruct-Q4_K_M.gguf"
+};
+var DEFAULT_MODEL = "smollm2-135m";
+var downloadFile = (url, destPath) => {
+  return new Promise((resolve, reject) => {
+    const file = fs.createWriteStream(destPath);
+    https.get(url, (response) => {
+      if (response.statusCode === 302 || response.statusCode === 301) {
+        downloadFile(response.headers.location, destPath).then(resolve).catch(reject);
+        return;
+      }
+      if (response.statusCode !== 200) {
+        reject(new Error(`Failed to download: ${response.statusCode}`));
+        return;
+      }
+      response.pipe(file);
+      file.on("finish", () => {
+        file.close();
+        resolve();
+      });
+    }).on("error", (err) => {
+      fs.unlink(destPath, () => {
+      });
+      reject(err);
+    });
+  });
+};
+var createNativeCortex = (config) => {
+  let status = {
+    id: "native-init",
+    model: config.model || DEFAULT_MODEL,
+    ready: false,
+    engine: "node-llama-cpp"
+  };
+  let llama;
+  let model;
+  let context;
+  let session;
+  let featureExtraction = null;
+  const MODELS_DIR = path.join(process.cwd(), "local_infrastructure", "models");
+  const init = async () => {
+    if (status.ready) return status;
+    try {
+      console.log("> Initializing Native Cortex...");
+      console.log("> Loading Embedding Model (all-MiniLM-L6-v2)...");
+      const { pipeline: pipeline2 } = await import("@xenova/transformers");
+      featureExtraction = await pipeline2("feature-extraction", "Xenova/all-MiniLM-L6-v2");
+      const ensureDirectoryExists = (dirPath) => {
+        if (!fs.existsSync(dirPath)) fs.mkdirSync(dirPath, { recursive: true });
+      };
+      ensureDirectoryExists(MODELS_DIR);
+      const modelKey = config.model || DEFAULT_MODEL;
+      const modelUrl = MODEL_URLS[modelKey] || MODEL_URLS[DEFAULT_MODEL];
+      const modelFileName = path.basename(modelUrl);
+      const modelPath = path.join(MODELS_DIR, modelFileName);
+      if (!fs.existsSync(modelPath)) {
+        console.log(`> Downloading SLM: ${modelKey}...`);
+        await downloadFile(modelUrl, modelPath);
+        console.log(`> Download complete.`);
+      }
+      const { getLlama, LlamaChatSession } = await import("node-llama-cpp");
+      llama = await getLlama();
+      console.log("> Loading SLM into memory...");
+      model = await llama.loadModel({
+        modelPath,
+        gpuLayers: config.gpu ? 99 : 0
+      });
+      context = await model.createContext();
+      session = new LlamaChatSession({
+        contextSequence: context.getSequence()
+      });
+      status = {
+        id: `ctx_${Date.now()}`,
+        model: modelKey,
+        ready: true,
+        engine: "node-llama-cpp"
+      };
+      console.log("> Cortex Ready.");
+      return status;
+    } catch (e) {
+      console.error("Failed to initialize Native Cortex:", e);
+      throw e;
+    }
+  };
+  const complete = async (prompt, options = {}) => {
+    if (!status.ready) await init();
+    return await session.prompt(prompt, {
+      maxTokens: options.maxTokens,
+      temperature: options.temperature
+    });
+  };
+  const completeStream = async function* (prompt, options = {}) {
+    if (!status.ready) await init();
+    const tokenQueue = [];
+    let resolveToken = null;
+    let done = false;
+    session.prompt(prompt, {
+      maxTokens: options.maxTokens,
+      temperature: options.temperature,
+      onToken: (token) => {
+        tokenQueue.push(token);
+        if (resolveToken) {
+          resolveToken();
+          resolveToken = null;
+        }
+      }
+    }).then(() => {
+      done = true;
+      if (resolveToken) {
+        resolveToken();
+        resolveToken = null;
+      }
+    }).catch((e) => {
+      console.error("Stream failed:", e);
+      done = true;
+      if (resolveToken) {
+        resolveToken();
+        resolveToken = null;
+      }
+    });
+    while (!done || tokenQueue.length > 0) {
+      if (tokenQueue.length === 0) {
+        await new Promise((resolve) => {
+          resolveToken = resolve;
+        });
+      }
+      while (tokenQueue.length > 0) {
+        yield tokenQueue.shift();
+      }
+    }
+  };
+  const embed = async (text) => {
+    if (!status.ready) await init();
+    try {
+      const output = await featureExtraction(text, { pooling: "mean", normalize: true });
+      return Array.from(output.data);
+    } catch (e) {
+      console.error("Embedding failed:", e);
+      return new Array(384).fill(0);
+    }
+  };
+  return {
+    init,
+    complete,
+    completeStream,
+    embed
+  };
+};
+var createCortex = (config) => createNativeCortex(config);
+
+// src/memory.ts
+var path3 = __toESM(require("path"));
+
+// src/vector.ts
+var path2 = __toESM(require("path"));
+var fs2 = __toESM(require("fs"));
+var pipeline;
+var lancedb;
+var initVectorEngine = async () => {
+  if (pipeline) return;
+  try {
+    console.log("> Initializing Vector Engine (Transformers)...");
+    const transformers = await import("@xenova/transformers");
+    transformers.env.cacheDir = path2.join(process.env.HOME || ".", ".forbocai", "cache");
+    pipeline = await transformers.pipeline("feature-extraction", "Xenova/all-MiniLM-L6-v2");
+    console.log("> Initializing LanceDB...");
+    lancedb = await import("@lancedb/lancedb");
+  } catch (e) {
+    console.error("Failed to init Vector Engine:", e);
+  }
+};
+var generateEmbedding = async (text) => {
+  try {
+    if (!pipeline) await initVectorEngine();
+    const output = await pipeline(text, { pooling: "mean", normalize: true });
+    return Array.from(output.data);
+  } catch (e) {
+    console.warn("Transformers embedding failed, falling back to Cortex:", e);
+    const cortexConfig = {
+      model: "smollm2-135m",
+      temperature: 0.7,
+      maxTokens: 128,
+      gpu: true
+    };
+    const cortex = createCortex(cortexConfig);
+    try {
+      await cortex.init();
+      return await cortex.embed(text);
+    } catch (cortexError) {
+      console.error("All embedding methods failed:", cortexError);
+      return new Array(384).fill(0);
+    }
+  }
+};
+var getVectorTable = async (dbPath, tableName = "memories") => {
+  if (!lancedb) await initVectorEngine();
+  if (!fs2.existsSync(dbPath)) fs2.mkdirSync(dbPath, { recursive: true });
+  const db = await lancedb.connect(dbPath);
+  const tables = await db.tableNames();
+  if (tables.includes(tableName)) {
+    return await db.openTable(tableName);
+  } else {
+    return null;
+  }
+};
+var createTable = async (dbPath, tableName, data) => {
+  if (!lancedb) await initVectorEngine();
+  const db = await lancedb.connect(dbPath);
+  return await db.createTable(tableName, data);
+};
+
+// src/memory.ts
+var createMemoryItem = (text, type = "observation", importance = 0.5) => ({
+  id: `mem_${Date.now()}_${Math.random().toString(36).substring(7)}`,
+  text,
+  timestamp: Date.now(),
+  type,
+  importance: Math.min(1, Math.max(0, importance))
+});
+var createLanceDBMemory = (config) => {
+  const dbName = config.storageKey || "forbocai_vectors";
+  const dbPath = path3.join(process.cwd(), "local_infrastructure", "vectors", dbName + ".lance");
+  const tableName = "memories";
+  let _table = null;
+  const getTable = async () => {
+    if (_table) return _table;
+    _table = await getVectorTable(dbPath, tableName);
+    return _table;
+  };
+  const store = async (text, type = "observation", importance = 0.5) => {
+    const item = createMemoryItem(text, type, importance);
+    const vector = await generateEmbedding(text);
+    const record = {
+      ...item,
+      vector
+    };
+    const existingTable = await getTable();
+    if (existingTable) {
+      await existingTable.add([record]);
+    } else {
+      _table = await createTable(dbPath, tableName, [record]);
+    }
+    return item;
+  };
+  const recall = async (query, limit = 5) => {
+    const table = await getTable();
+    if (!table) return [];
+    const queryVec = await generateEmbedding(query);
+    const results = await table.search(queryVec).limit(limit).execute();
+    return results.map((r) => ({
+      id: r.id,
+      text: r.text,
+      timestamp: r.timestamp,
+      type: r.type,
+      importance: r.importance
+    }));
+  };
+  const list = async (limit = 50, offset = 0) => {
+    const table = await getTable();
+    if (!table) return [];
+    const results = await table.query().limit(limit + offset).execute();
+    return results.slice(offset).map((r) => ({
+      id: r.id,
+      text: r.text,
+      timestamp: r.timestamp,
+      type: r.type,
+      importance: r.importance
+    }));
+  };
+  const exportMemories = async () => {
+    const table = await getTable();
+    if (!table) return [];
+    const results = await table.query().execute();
+    return results.map((r) => ({
+      id: r.id,
+      text: r.text,
+      timestamp: r.timestamp,
+      type: r.type,
+      importance: r.importance
+    }));
+  };
+  const importMemories = async (memories) => {
+    if (memories.length === 0) return;
+    const records = [];
+    for (const mem of memories) {
+      const vector = await generateEmbedding(mem.text);
+      records.push({
+        ...mem,
+        vector
+      });
+    }
+    const existingTable = await getTable();
+    if (existingTable) {
+      await existingTable.add(records);
+    } else {
+      _table = await createTable(dbPath, tableName, records);
+    }
+  };
+  const clear = async () => {
+    const tablePath = path3.join(dbPath, tableName + ".lance");
+    try {
+      const fs3 = await import("fs");
+      if (fs3.existsSync(tablePath)) {
+        fs3.rmSync(tablePath, { recursive: true, force: true });
+      }
+      if (fs3.existsSync(dbPath)) {
+        fs3.rmSync(dbPath, { recursive: true, force: true });
+      }
+      _table = null;
+      console.log("> Memory cleared successfully");
+    } catch (e) {
+      console.error("Failed to clear memory:", e);
+      throw e;
+    }
+  };
+  return { store, recall, list, export: exportMemories, import: importMemories, clear };
+};
+var createMemory = (config = {}) => createLanceDBMemory(config);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createCortex,
+  createMemory,
+  createMemoryItem,
+  createTable,
+  generateEmbedding,
+  getVectorTable,
+  initVectorEngine
+});

package/dist/index.mjs

@@ -0,0 +1,337 @@
+// src/cortex.ts
+import * as fs from "fs";
+import * as path from "path";
+import * as https from "https";
+var isNode = typeof process !== "undefined" && process.versions != null && process.versions.node != null;
+if (!isNode) {
+  throw new Error("ForbocAI SDK requires Node.js environment - browser support has been removed");
+}
+var MODEL_URLS = {
+  "smollm2-135m": "https://huggingface.co/bartowski/SmolLM2-135M-Instruct-GGUF/resolve/main/SmolLM2-135M-Instruct-Q4_K_M.gguf",
+  "llama3-8b": "https://huggingface.co/lmstudio-community/Meta-Llama-3-8B-Instruct-GGUF/resolve/main/Meta-Llama-3-8B-Instruct-Q4_K_M.gguf"
+};
+var DEFAULT_MODEL = "smollm2-135m";
+var downloadFile = (url, destPath) => {
+  return new Promise((resolve, reject) => {
+    const file = fs.createWriteStream(destPath);
+    https.get(url, (response) => {
+      if (response.statusCode === 302 || response.statusCode === 301) {
+        downloadFile(response.headers.location, destPath).then(resolve).catch(reject);
+        return;
+      }
+      if (response.statusCode !== 200) {
+        reject(new Error(`Failed to download: ${response.statusCode}`));
+        return;
+      }
+      response.pipe(file);
+      file.on("finish", () => {
+        file.close();
+        resolve();
+      });
+    }).on("error", (err) => {
+      fs.unlink(destPath, () => {
+      });
+      reject(err);
+    });
+  });
+};
+var createNativeCortex = (config) => {
+  let status = {
+    id: "native-init",
+    model: config.model || DEFAULT_MODEL,
+    ready: false,
+    engine: "node-llama-cpp"
+  };
+  let llama;
+  let model;
+  let context;
+  let session;
+  let featureExtraction = null;
+  const MODELS_DIR = path.join(process.cwd(), "local_infrastructure", "models");
+  const init = async () => {
+    if (status.ready) return status;
+    try {
+      console.log("> Initializing Native Cortex...");
+      console.log("> Loading Embedding Model (all-MiniLM-L6-v2)...");
+      const { pipeline: pipeline2 } = await import("@xenova/transformers");
+      featureExtraction = await pipeline2("feature-extraction", "Xenova/all-MiniLM-L6-v2");
+      const ensureDirectoryExists = (dirPath) => {
+        if (!fs.existsSync(dirPath)) fs.mkdirSync(dirPath, { recursive: true });
+      };
+      ensureDirectoryExists(MODELS_DIR);
+      const modelKey = config.model || DEFAULT_MODEL;
+      const modelUrl = MODEL_URLS[modelKey] || MODEL_URLS[DEFAULT_MODEL];
+      const modelFileName = path.basename(modelUrl);
+      const modelPath = path.join(MODELS_DIR, modelFileName);
+      if (!fs.existsSync(modelPath)) {
+        console.log(`> Downloading SLM: ${modelKey}...`);
+        await downloadFile(modelUrl, modelPath);
+        console.log(`> Download complete.`);
+      }
+      const { getLlama, LlamaChatSession } = await import("node-llama-cpp");
+      llama = await getLlama();
+      console.log("> Loading SLM into memory...");
+      model = await llama.loadModel({
+        modelPath,
+        gpuLayers: config.gpu ? 99 : 0
+      });
+      context = await model.createContext();
+      session = new LlamaChatSession({
+        contextSequence: context.getSequence()
+      });
+      status = {
+        id: `ctx_${Date.now()}`,
+        model: modelKey,
+        ready: true,
+        engine: "node-llama-cpp"
+      };
+      console.log("> Cortex Ready.");
+      return status;
+    } catch (e) {
+      console.error("Failed to initialize Native Cortex:", e);
+      throw e;
+    }
+  };
+  const complete = async (prompt, options = {}) => {
+    if (!status.ready) await init();
+    return await session.prompt(prompt, {
+      maxTokens: options.maxTokens,
+      temperature: options.temperature
+    });
+  };
+  const completeStream = async function* (prompt, options = {}) {
+    if (!status.ready) await init();
+    const tokenQueue = [];
+    let resolveToken = null;
+    let done = false;
+    session.prompt(prompt, {
+      maxTokens: options.maxTokens,
+      temperature: options.temperature,
+      onToken: (token) => {
+        tokenQueue.push(token);
+        if (resolveToken) {
+          resolveToken();
+          resolveToken = null;
+        }
+      }
+    }).then(() => {
+      done = true;
+      if (resolveToken) {
+        resolveToken();
+        resolveToken = null;
+      }
+    }).catch((e) => {
+      console.error("Stream failed:", e);
+      done = true;
+      if (resolveToken) {
+        resolveToken();
+        resolveToken = null;
+      }
+    });
+    while (!done || tokenQueue.length > 0) {
+      if (tokenQueue.length === 0) {
+        await new Promise((resolve) => {
+          resolveToken = resolve;
+        });
+      }
+      while (tokenQueue.length > 0) {
+        yield tokenQueue.shift();
+      }
+    }
+  };
+  const embed = async (text) => {
+    if (!status.ready) await init();
+    try {
+      const output = await featureExtraction(text, { pooling: "mean", normalize: true });
+      return Array.from(output.data);
+    } catch (e) {
+      console.error("Embedding failed:", e);
+      return new Array(384).fill(0);
+    }
+  };
+  return {
+    init,
+    complete,
+    completeStream,
+    embed
+  };
+};
+var createCortex = (config) => createNativeCortex(config);
+
+// src/memory.ts
+import * as path3 from "path";
+
+// src/vector.ts
+import * as path2 from "path";
+import * as fs2 from "fs";
+var pipeline;
+var lancedb;
+var initVectorEngine = async () => {
+  if (pipeline) return;
+  try {
+    console.log("> Initializing Vector Engine (Transformers)...");
+    const transformers = await import("@xenova/transformers");
+    transformers.env.cacheDir = path2.join(process.env.HOME || ".", ".forbocai", "cache");
+    pipeline = await transformers.pipeline("feature-extraction", "Xenova/all-MiniLM-L6-v2");
+    console.log("> Initializing LanceDB...");
+    lancedb = await import("@lancedb/lancedb");
+  } catch (e) {
+    console.error("Failed to init Vector Engine:", e);
+  }
+};
+var generateEmbedding = async (text) => {
+  try {
+    if (!pipeline) await initVectorEngine();
+    const output = await pipeline(text, { pooling: "mean", normalize: true });
+    return Array.from(output.data);
+  } catch (e) {
+    console.warn("Transformers embedding failed, falling back to Cortex:", e);
+    const cortexConfig = {
+      model: "smollm2-135m",
+      temperature: 0.7,
+      maxTokens: 128,
+      gpu: true
+    };
+    const cortex = createCortex(cortexConfig);
+    try {
+      await cortex.init();
+      return await cortex.embed(text);
+    } catch (cortexError) {
+      console.error("All embedding methods failed:", cortexError);
+      return new Array(384).fill(0);
+    }
+  }
+};
+var getVectorTable = async (dbPath, tableName = "memories") => {
+  if (!lancedb) await initVectorEngine();
+  if (!fs2.existsSync(dbPath)) fs2.mkdirSync(dbPath, { recursive: true });
+  const db = await lancedb.connect(dbPath);
+  const tables = await db.tableNames();
+  if (tables.includes(tableName)) {
+    return await db.openTable(tableName);
+  } else {
+    return null;
+  }
+};
+var createTable = async (dbPath, tableName, data) => {
+  if (!lancedb) await initVectorEngine();
+  const db = await lancedb.connect(dbPath);
+  return await db.createTable(tableName, data);
+};
+
+// src/memory.ts
+var createMemoryItem = (text, type = "observation", importance = 0.5) => ({
+  id: `mem_${Date.now()}_${Math.random().toString(36).substring(7)}`,
+  text,
+  timestamp: Date.now(),
+  type,
+  importance: Math.min(1, Math.max(0, importance))
+});
+var createLanceDBMemory = (config) => {
+  const dbName = config.storageKey || "forbocai_vectors";
+  const dbPath = path3.join(process.cwd(), "local_infrastructure", "vectors", dbName + ".lance");
+  const tableName = "memories";
+  let _table = null;
+  const getTable = async () => {
+    if (_table) return _table;
+    _table = await getVectorTable(dbPath, tableName);
+    return _table;
+  };
+  const store = async (text, type = "observation", importance = 0.5) => {
+    const item = createMemoryItem(text, type, importance);
+    const vector = await generateEmbedding(text);
+    const record = {
+      ...item,
+      vector
+    };
+    const existingTable = await getTable();
+    if (existingTable) {
+      await existingTable.add([record]);
+    } else {
+      _table = await createTable(dbPath, tableName, [record]);
+    }
+    return item;
+  };
+  const recall = async (query, limit = 5) => {
+    const table = await getTable();
+    if (!table) return [];
+    const queryVec = await generateEmbedding(query);
+    const results = await table.search(queryVec).limit(limit).execute();
+    return results.map((r) => ({
+      id: r.id,
+      text: r.text,
+      timestamp: r.timestamp,
+      type: r.type,
+      importance: r.importance
+    }));
+  };
+  const list = async (limit = 50, offset = 0) => {
+    const table = await getTable();
+    if (!table) return [];
+    const results = await table.query().limit(limit + offset).execute();
+    return results.slice(offset).map((r) => ({
+      id: r.id,
+      text: r.text,
+      timestamp: r.timestamp,
+      type: r.type,
+      importance: r.importance
+    }));
+  };
+  const exportMemories = async () => {
+    const table = await getTable();
+    if (!table) return [];
+    const results = await table.query().execute();
+    return results.map((r) => ({
+      id: r.id,
+      text: r.text,
+      timestamp: r.timestamp,
+      type: r.type,
+      importance: r.importance
+    }));
+  };
+  const importMemories = async (memories) => {
+    if (memories.length === 0) return;
+    const records = [];
+    for (const mem of memories) {
+      const vector = await generateEmbedding(mem.text);
+      records.push({
+        ...mem,
+        vector
+      });
+    }
+    const existingTable = await getTable();
+    if (existingTable) {
+      await existingTable.add(records);
+    } else {
+      _table = await createTable(dbPath, tableName, records);
+    }
+  };
+  const clear = async () => {
+    const tablePath = path3.join(dbPath, tableName + ".lance");
+    try {
+      const fs3 = await import("fs");
+      if (fs3.existsSync(tablePath)) {
+        fs3.rmSync(tablePath, { recursive: true, force: true });
+      }
+      if (fs3.existsSync(dbPath)) {
+        fs3.rmSync(dbPath, { recursive: true, force: true });
+      }
+      _table = null;
+      console.log("> Memory cleared successfully");
+    } catch (e) {
+      console.error("Failed to clear memory:", e);
+      throw e;
+    }
+  };
+  return { store, recall, list, export: exportMemories, import: importMemories, clear };
+};
+var createMemory = (config = {}) => createLanceDBMemory(config);
+export {
+  createCortex,
+  createMemory,
+  createMemoryItem,
+  createTable,
+  generateEmbedding,
+  getVectorTable,
+  initVectorEngine
+};

package/package.json

@@ -0,0 +1,31 @@
+{
+    "name": "@forbocai/node",
+    "version": "0.4.4",
+    "license": "UNLICENSED",
+    "description": "Node.js native implementation for ForbocAI SDK",
+    "main": "dist/index.js",
+    "module": "dist/index.mjs",
+    "types": "dist/index.d.ts",
+    "scripts": {
+        "build": "tsup src/index.ts --format cjs,esm --dts",
+        "dev": "tsup src/index.ts --watch",
+        "test": "vitest"
+    },
+    "dependencies": {
+        "@forbocai/core": "*",
+        "@lancedb/lancedb": "^0.23.0",
+        "@xenova/transformers": "^2.17.2",
+        "apache-arrow": "^18.1.0",
+        "node-llama-cpp": "^3.15.1",
+        "onnxruntime-node": "^1.23.2"
+    },
+    "devDependencies": {
+        "tsup": "^8.5.1",
+        "typescript": "^5.9.3",
+        "vitest": "^1.0.0"
+    },
+    "files": [
+        "dist",
+        "package.json"
+    ]
+}