forbocai 0.3.0 → 0.3.3

package/dist/index.js

@@ -1,7 +1,9 @@
 "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)
@@ -15,19 +17,20 @@ var __copyProps = (to, from, except, desc) => {
   }
   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, {
-  GhostSession: () => GhostSession,
-  MockBridge: () => MockBridge,
-  MockCortex: () => MockCortex,
-  MockMemory: () => MockMemory,
-  SoulImpl: () => SoulImpl,
-  applyTemporalDecay: () => applyTemporalDecay,
   attackRule: () => attackRule,
-  computeSimilarity: () => computeSimilarity,
   createAgent: () => createAgent,
   createAgentFromSoul: () => createAgentFromSoul,
   createBridge: () => createBridge,
@@ -38,25 +41,28 @@ __export(index_exports, {
   createMemoryItem: () => createMemoryItem,
   createSoul: () => createSoul,
   createSoulInstance: () => createSoulInstance,
+  createTable: () => createTable,
   deserializeSoul: () => deserializeSoul,
   exportSoulToIPFS: () => exportSoulToIPFS,
   exportToSoul: () => exportToSoul,
   fromSoul: () => fromSoul,
-  generateActionFromDirective: () => generateActionFromDirective,
-  generateCompletion: () => generateCompletion,
+  generateEmbedding: () => generateEmbedding,
+  getGhostHistory: () => getGhostHistory,
   getGhostResults: () => getGhostResults,
   getGhostStatus: () => getGhostStatus,
+  getSoulList: () => getSoulList,
+  getVectorTable: () => getVectorTable,
   importSoulFromIPFS: () => importSoulFromIPFS,
   init: () => init,
+  initVectorEngine: () => initVectorEngine,
   interactRule: () => interactRule,
   movementRule: () => movementRule,
   processAgentInput: () => processAgentInput,
-  processObservationToDirective: () => processObservationToDirective,
-  rankMemoriesByRelevance: () => rankMemoriesByRelevance,
   resourceRule: () => resourceRule,
   serializeSoul: () => serializeSoul,
   speakRule: () => speakRule,
   startGhostSession: () => startGhostSession,
+  stopGhostSession: () => stopGhostSession,
   updateAgentState: () => updateAgentState,
   validateAction: () => validateAction,
   validateSoul: () => validateSoul,
@@ -65,151 +71,181 @@ __export(index_exports, {
 module.exports = __toCommonJS(index_exports);
 
 // src/cortex.ts
-var import_web_llm = require("@mlc-ai/web-llm");
-var MODEL_CONFIG = {
-  "smollm2-135m": "HuggingFaceTB/SmolLM2-135M-Instruct-q4f16_1-MLC",
-  "llama3-8b": "Llama-3-8B-Instruct-q4f16_1-MLC",
-  "default": "HuggingFaceTB/SmolLM2-135M-Instruct-q4f16_1-MLC"
+var fs = __toESM(require("fs"));
+var path = __toESM(require("path"));
+var https = __toESM(require("https"));
+var MODEL_URLS = {
+  "smollm2-135m": "https://huggingface.co/HuggingFaceTB/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 createCortex = (config) => {
-  return new WebLLMCortex(config);
-};
-var generateCompletion = (prompt, options, modelId) => {
-  const temperature = options.temperature ?? 0.7;
-  return `[Mock Response] Model: ${modelId}, Temp: ${temperature}. Response to: ${prompt}`;
+var DEFAULT_MODEL = "smollm2-135m";
+var ensureDirectoryExists = (dirPath) => {
+  if (!fs.existsSync(dirPath)) {
+    fs.mkdirSync(dirPath, { recursive: true });
+  }
 };
-var processObservationToDirective = (observation) => {
-  return {
-    type: "system-prompt",
-    content: "You are an autonomous agent in a game world. Process the observation and generate appropriate actions.",
-    priority: "normal"
-  };
+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 generateActionFromDirective = (directive) => {
-  return {
-    type: "idle",
-    reason: directive.content ?? "No specific directive provided"
+var createNativeCortex = (config) => {
+  let status = {
+    id: "native-init",
+    model: config.model || DEFAULT_MODEL,
+    ready: false,
+    engine: "node-llama-cpp"
   };
-};
-var WebLLMCortex = class {
-  constructor(config) {
-    this.status = null;
-    this.engine = null;
-    this.config = {
-      ...config,
-      temperature: config.temperature ?? 0.7,
-      maxTokens: config.maxTokens ?? 1024,
-      gpu: config.gpu ?? true
-    };
-  }
-  async init() {
-    if (this.status?.ready) {
-      return this.status;
-    }
+  let llama;
+  let model;
+  let context;
+  let session;
+  const MODELS_DIR = path.join(process.cwd(), "local_infrastructure", "models");
+  const init2 = async () => {
+    if (status.ready) return status;
     try {
-      const isBrowser = typeof window !== "undefined";
-      if (isBrowser && this.config.gpu) {
-        console.log(`> Initializing WebLLM with model: ${this.config.model}`);
-        const selectedModel = MODEL_CONFIG[this.config.model] || MODEL_CONFIG["default"];
-        this.engine = await (0, import_web_llm.CreateMLCEngine)(selectedModel, {
-          initProgressCallback: (progress) => {
-            console.log(`> Model Loading: ${(progress.progress * 100).toFixed(1)}% - ${progress.text}`);
-          }
-        });
-        this.status = {
-          id: "webllm-" + Math.random().toString(36).substring(7),
-          model: this.config.model,
-          ready: true,
-          engine: "webllm"
-        };
-        return this.status;
+      console.log("> Initializing Native Cortex (node-llama-cpp)...");
+      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 Model: ${modelKey}...`);
+        console.log(`> Source: ${modelUrl}`);
+        await downloadFile(modelUrl, modelPath);
+        console.log(`> Download complete.`);
       } else {
-        console.warn("WebGPU unavailable (Node.js or disabled). Falling back to mock/API.");
-        throw new Error("WebGPU unavailable");
+        console.log(`> Using cached model: ${modelPath}`);
       }
-    } catch (e) {
-      console.warn("Using offline/mock mode due to initialization failure:", e);
-      this.status = {
-        id: "offline-" + Math.random().toString(36).substring(7),
-        model: this.config.model,
+      const { getLlama, LlamaChatSession } = await import("node-llama-cpp");
+      llama = await getLlama();
+      console.log("> Loading model into memory...");
+      model = await llama.loadModel({
+        modelPath,
+        gpuLayers: config.gpu ? 99 : 0
+        // Try to use GPU if allowed
+      });
+      console.log("> Creating context...");
+      context = await model.createContext();
+      session = new LlamaChatSession({
+        contextSequence: context.getSequence()
+      });
+      status = {
+        id: `ctx_${Date.now()}`,
+        model: modelKey,
         ready: true,
-        engine: "mock"
+        engine: "node-llama-cpp"
       };
-      return this.status;
-    }
-  }
-  async complete(prompt, options = {}) {
-    if (!this.status?.ready) await this.init();
-    if (this.engine) {
-      const response = await this.engine.chat.completions.create({
-        messages: [{ role: "user", content: prompt }],
-        temperature: options.temperature ?? this.config.temperature,
-        max_tokens: options.maxTokens ?? this.config.maxTokens
-      });
-      return response.choices[0]?.message?.content || "";
-    } else {
-      return generateCompletion(prompt, options, this.config.model);
+      console.log("> Cortex Ready.");
+      return status;
+    } catch (e) {
+      console.error("Failed to initialize Native Cortex:", e);
+      throw e;
     }
-  }
-  async *completeStream(prompt, options = {}) {
-    if (!this.status?.ready) await this.init();
-    if (this.engine) {
-      const stream = await this.engine.chat.completions.create({
-        messages: [{ role: "user", content: prompt }],
-        temperature: options.temperature ?? this.config.temperature,
-        max_tokens: options.maxTokens ?? this.config.maxTokens,
-        stream: true
-      });
-      for await (const chunk of stream) {
-        const content = chunk.choices[0]?.delta?.content || "";
-        if (content) yield content;
+  };
+  const complete = async (prompt, options = {}) => {
+    if (!status.ready) await init2();
+    return await session.prompt(prompt, {
+      maxTokens: options.maxTokens,
+      temperature: options.temperature
+    });
+  };
+  const completeStream = async function* (prompt, options = {}) {
+    if (!status.ready) await init2();
+    const tokenQueue = [];
+    let resolveNext = null;
+    let isComplete = false;
+    const generationPromise = session.prompt(prompt, {
+      maxTokens: options.maxTokens,
+      temperature: options.temperature,
+      onToken: (tokens) => {
+        try {
+          const text = model.detokenize(tokens);
+          if (text) {
+            tokenQueue.push(text);
+            if (resolveNext) {
+              resolveNext();
+              resolveNext = null;
+            }
+          }
+        } catch {
+          tokenQueue.push(tokens.map((t) => String.fromCharCode(t % 256)).join(""));
+        }
       }
-    } else {
-      const result = generateCompletion(prompt, options, this.config.model);
-      for (const char of result) {
-        await new Promise((r) => setTimeout(r, 10));
-        yield char;
+    }).then(() => {
+      isComplete = true;
+      if (resolveNext) resolveNext();
+    });
+    while (!isComplete || tokenQueue.length > 0) {
+      if (tokenQueue.length > 0) {
+        yield tokenQueue.shift();
+      } else if (!isComplete) {
+        await new Promise((resolve) => {
+          resolveNext = resolve;
+        });
       }
     }
-  }
-  async processObservation(observation) {
-    return processObservationToDirective(observation);
-  }
-  async generateAction(directive) {
-    return generateActionFromDirective(directive);
-  }
-};
-var MockCortex = class {
-  async init() {
-    return {
-      id: "mock-cortex",
-      model: "mock-model",
-      ready: true,
-      engine: "mock"
-    };
-  }
-  async complete(prompt) {
-    return `Mock response to: ${prompt}`;
-  }
-  async *completeStream(prompt) {
-    yield `Mock `;
-    yield `streaming `;
-    yield `response `;
-    yield `to: ${prompt}`;
-  }
-  async processObservation(observation) {
-    return {
-      type: "system-prompt",
-      content: "Mock processing"
-    };
-  }
-  async generateAction(directive) {
-    return {
-      type: "mock-action",
-      reason: "Mock action"
-    };
-  }
+    await generationPromise;
+  };
+  const embed = async (text) => {
+    if (!status.ready) await init2();
+    try {
+      return new Array(384).fill(0).map(() => Math.random());
+    } catch (e) {
+      return [];
+    }
+  };
+  const processObservation = async (obs) => {
+    const prompt = `System: You are an agent.
+Observation: ${obs.content}
+Task: Generete a JSON directive { "type": "...", "content": "..." }.`;
+    const res = await complete(prompt);
+    try {
+      return JSON.parse(res);
+    } catch {
+      return { type: "thought", content: res };
+    }
+  };
+  const generateAction = async (dir) => {
+    const prompt = `Directive: ${dir.content}. Generate JSON action.`;
+    const res = await complete(prompt);
+    try {
+      return JSON.parse(res);
+    } catch {
+      return { type: "idle", reason: res };
+    }
+  };
+  return {
+    init: init2,
+    complete,
+    completeStream,
+    processObservation,
+    generateAction,
+    embed
+    // Extended interface for private use by Memory
+  };
 };
+var createCortex = (config) => createNativeCortex(config);
 
 // src/agent.ts
 var createInitialState = (partial) => {
@@ -252,19 +288,19 @@ var exportToSoul = (agentId, name, persona, state, memories) => {
   };
 };
 var createAgent = (config) => {
-  return new AgentImpl(config);
-};
-var AgentImpl = class {
-  constructor(config) {
-    this.config = config;
-    this.cortex = config.cortex;
-    this.state = createInitialState(config.initialState);
-    this.memories = [];
-  }
-  async process(input, context = {}) {
-    const currentState = this.getState();
+  let state = createInitialState(config.initialState);
+  let memories = [];
+  const cortex = config.cortex;
+  const apiUrl = config.apiUrl || "http://localhost:8080";
+  const getAgentState = () => {
+    return { ...state };
+  };
+  const setAgentState = (newState) => {
+    state = newState;
+  };
+  const process2 = async (input, context = {}) => {
+    const currentState = getAgentState();
     const hp = currentState.hp || 100;
-    const apiUrl = this.config.apiUrl || "http://localhost:8080";
     const apiContext = Object.entries(context).map(([k, v]) => [k, String(v)]);
     apiContext.push(["hp", String(hp)]);
     let directive = "Respond normally.";
@@ -292,227 +328,348 @@ var AgentImpl = class {
 
 User: ${input}
 Agent:`;
-    const generatedText = await this.cortex.complete(prompt);
+    const generatedText = await cortex.complete(prompt);
     return {
       dialogue: generatedText,
       action: { type: instruction, reason: directive },
       thought: `Directive: ${directive}`
     };
-  }
-  getState() {
-    return { ...this.state };
-  }
-  setState(newState) {
-    this.state = newState;
-  }
-  export() {
+  };
+  const exportSoul = () => {
     return exportToSoul(
       "agent-" + Math.random().toString(36).substring(7),
       "Agent",
-      this.config.persona,
-      this.state,
-      this.memories
+      config.persona,
+      state,
+      memories
     );
-  }
+  };
+  return {
+    process: process2,
+    getState: getAgentState,
+    setState: setAgentState,
+    export: exportSoul
+  };
 };
-var fromSoul = (soul, cortex) => {
+var fromSoul = (soul, cortex, memory) => {
   const agent = createAgent({
+    id: soul.id,
     cortex,
+    memory: memory || null,
     persona: soul.persona,
     initialState: soul.state
   });
   return agent;
 };
 
-// src/memory.ts
-var import_idb = require("idb");
-var createMemoryItem = (text, type = "observation", importance = 0.5) => {
-  return {
-    id: `mem_${Date.now()}_${Math.random().toString(36).substring(7)}`,
-    text,
-    timestamp: Date.now(),
-    type,
-    importance: Math.max(0, Math.min(1, importance))
-    // Clamp 0-1
-  };
+// src/soul.ts
+var heliaNode = null;
+var heliaJson = null;
+var getHelia = async () => {
+  if (heliaNode) return { node: heliaNode, j: heliaJson };
+  try {
+    const { createHelia } = await import("helia");
+    const { json } = await import("@helia/json");
+    const { MemoryBlockstore } = await import("blockstore-core");
+    const blockstore = new MemoryBlockstore();
+    heliaNode = await createHelia({ blockstore });
+    heliaJson = json(heliaNode);
+    console.log("> Helia IPFS Node Initialized:", heliaNode.libp2p.peerId.toString());
+    return { node: heliaNode, j: heliaJson };
+  } catch (e) {
+    console.warn("Failed to init Helia (IPFS):", e);
+    return null;
+  }
 };
-var applyTemporalDecay = (memory, currentTime, decayRate = 1e-3) => {
-  const ageMs = currentTime - memory.timestamp;
-  const ageHours = ageMs / (1e3 * 60 * 60);
-  const decayFactor = Math.exp(-decayRate * ageHours);
+var createSoul = (id, name, persona, state, memories = []) => {
   return {
-    ...memory,
-    importance: memory.importance * decayFactor
+    id,
+    version: "1.0.0",
+    name,
+    persona,
+    state: { ...state },
+    memories: [...memories]
   };
 };
-var computeSimilarity = (text1, text2) => {
-  const words1 = new Set(text1.toLowerCase().split(/\s+/));
-  const words2 = new Set(text2.toLowerCase().split(/\s+/));
-  let intersection = 0;
-  words1.forEach((word) => {
-    if (words2.has(word)) intersection++;
-  });
-  const union = words1.size + words2.size - intersection;
-  return union > 0 ? intersection / union : 0;
+var serializeSoul = (soul) => {
+  return JSON.stringify(soul, null, 2);
 };
-var rankMemoriesByRelevance = (memories, query, limit = 5) => {
-  const scored = memories.map((mem) => ({
-    memory: mem,
-    score: computeSimilarity(mem.text, query) * mem.importance
-  }));
-  return scored.sort((a, b) => b.score - a.score).slice(0, limit).map((s) => s.memory);
+var deserializeSoul = (json) => {
+  const parsed = JSON.parse(json);
+  if (!parsed.id || !parsed.persona || !parsed.state) {
+    throw new Error("Invalid Soul format: missing required fields");
+  }
+  return {
+    id: parsed.id,
+    version: parsed.version || "1.0.0",
+    name: parsed.name || "Unknown",
+    persona: parsed.persona,
+    state: parsed.state,
+    memories: parsed.memories || [],
+    signature: parsed.signature
+  };
 };
-var createMemory = (config = {}) => {
-  return new IndexedDBMemory(config);
+var validateSoul = (soul) => {
+  const errors = [];
+  if (!soul.id) errors.push("Missing id");
+  if (!soul.persona) errors.push("Missing persona");
+  if (!soul.state) errors.push("Missing state");
+  if (!soul.state?.mood) errors.push("Missing state.mood");
+  return {
+    valid: errors.length === 0,
+    errors
+  };
 };
-var IndexedDBMemory = class {
-  constructor(config) {
-    this.DB_NAME = "forbocai_db";
-    this.STORE_NAME = "memories";
-    this.config = {
-      decay: config.decay ?? "none",
-      maxContextWindow: config.maxContextWindow ?? 10,
-      storageKey: config.storageKey ?? "forbocai_memory",
-      ...config
-    };
-    if (typeof window !== "undefined" && window.indexedDB) {
-      this.dbPromise = (0, import_idb.openDB)(this.config.storageKey || this.DB_NAME, 1, {
-        upgrade(db) {
-          if (!db.objectStoreNames.contains("memories")) {
-            const store = db.createObjectStore("memories", { keyPath: "id" });
-            store.createIndex("timestamp", "timestamp");
-            store.createIndex("agentId", "agentId");
-          }
-        }
-      });
-    } else {
-      console.warn("IndexedDB not available (Node.js environment). Falling back to in-memory.");
-      this.dbPromise = Promise.resolve({
-        getAll: async () => [],
-        put: async () => {
-        },
-        clear: async () => {
-        },
-        getAllFromIndex: async () => [],
-        transaction: () => ({ objectStore: () => ({ put: async () => {
-        } }), done: Promise.resolve() })
-      });
-    }
-  }
-  async getAllMemories() {
-    const db = await this.dbPromise;
-    try {
-      return await db.getAll(this.STORE_NAME) || [];
-    } catch {
-      return [];
-    }
-  }
-  async store(text, type = "observation", importance = 0.5) {
-    const memory = createMemoryItem(text, type, importance);
-    const db = await this.dbPromise;
-    try {
-      await db.put(this.STORE_NAME, memory);
-    } catch (e) {
-    }
-    if (this.config.apiUrl && this.config.agentId) {
-      this.syncToApi(text, importance).catch(() => {
-      });
+var exportSoulToIPFS = async (agentId, soul, config = {}) => {
+  if (config.useLocalNode !== false) {
+    const helia = await getHelia();
+    if (helia) {
+      try {
+        const cid = await helia.j.add(soul);
+        return {
+          cid: cid.toString(),
+          ipfsUrl: `ipfs://${cid.toString()}`,
+          soul
+        };
+      } catch (e) {
+        console.warn("Helia add failed, falling back to API", e);
+      }
     }
-    return memory;
   }
-  async syncToApi(text, importance) {
-    try {
-      await fetch(`${this.config.apiUrl}/agents/${this.config.agentId}/memory`, {
-        method: "POST",
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({ observation: text, importance })
-      });
-    } catch (e) {
+  const apiUrl = config.apiUrl || "https://forbocai-api.onrender.com";
+  try {
+    const response = await fetch(`${apiUrl}/agents/${agentId}/soul/export`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ agentIdRef: agentId })
+    });
+    if (!response.ok) {
+      throw new Error(`Export failed: ${response.statusText}`);
     }
+    const data = await response.json();
+    return {
+      cid: data.cid,
+      ipfsUrl: data.ipfsUrl,
+      signature: data.signature,
+      soul
+    };
+  } catch (e) {
+    const mockCid = `Qm${Buffer.from(soul.id).toString("base64").substring(0, 44)}`;
+    return {
+      cid: mockCid,
+      ipfsUrl: `ipfs://${mockCid}`,
+      soul
+    };
   }
-  async recall(query, limit = 5) {
-    let memories = await this.getAllMemories();
-    if (this.config.decay === "temporal") {
-      const now = Date.now();
-      memories = memories.map((mem) => applyTemporalDecay(mem, now));
-    }
-    const results = rankMemoriesByRelevance(memories, query, limit);
-    if (this.config.apiUrl && this.config.agentId) {
+};
+var importSoulFromIPFS = async (cid, config = {}) => {
+  if (config.useLocalNode !== false) {
+    const helia = await getHelia();
+    if (helia) {
       try {
-        const apiResults = await this.recallFromApi(query);
-        return [...results, ...apiResults.slice(0, limit - results.length)];
       } catch (e) {
       }
     }
-    return results;
   }
-  async recallFromApi(query) {
-    const response = await fetch(
-      `${this.config.apiUrl}/agents/${this.config.agentId}/memory/recall`,
-      {
-        method: "POST",
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({ query, similarity: 0.5 })
-      }
-    );
-    if (response.ok) return await response.json();
-    return [];
-  }
-  async list(limit = 50, offset = 0) {
-    const db = await this.dbPromise;
-    try {
-      const all = await db.getAllFromIndex(this.STORE_NAME, "timestamp");
-      return all.reverse().slice(offset, offset + limit);
-    } catch {
-      return [];
+  const apiUrl = config.apiUrl || "https://forbocai-api.onrender.com";
+  try {
+    const response = await fetch(`${apiUrl}/souls/${cid}`, {
+      method: "GET",
+      headers: { "Content-Type": "application/json" }
+    });
+    if (!response.ok) {
+      throw new Error(`Import failed: ${response.statusText}`);
     }
+    const data = await response.json();
+    return {
+      id: data.soulId,
+      version: "1.0.0",
+      name: data.soulName,
+      persona: data.dna,
+      state: { mood: "neutral", inventory: [], skills: {}, relationships: {} },
+      memories: []
+    };
+  } catch (e) {
+    throw new Error(`Failed to import Soul from CID ${cid}: ${e}`);
   }
-  async clear() {
-    const db = await this.dbPromise;
-    try {
-      await db.clear(this.STORE_NAME);
-    } catch {
+};
+var getSoulList = async (limit = 50, apiUrl) => {
+  const url = apiUrl || "https://forbocai-api.onrender.com";
+  try {
+    const response = await fetch(`${url}/souls?limit=${limit}`, {
+      method: "GET",
+      headers: { "Content-Type": "application/json" }
+    });
+    if (!response.ok) {
+      throw new Error(`Failed to get Soul list: ${response.statusText}`);
     }
+    const data = await response.json();
+    return data.souls.map((s) => ({
+      cid: s.cid || s.soulId,
+      name: s.name || s.soulName,
+      agentId: s.agentId,
+      exportedAt: s.exportedAt || s.createdAt,
+      ipfsUrl: s.ipfsUrl || `ipfs://${s.cid || s.soulId}`
+    }));
+  } catch (e) {
+    return [];
   }
-  async export() {
-    return this.getAllMemories();
+};
+var createAgentFromSoul = async (cid, cortexId, config = {}) => {
+  const apiUrl = config.apiUrl || "https://forbocai-api.onrender.com";
+  const response = await fetch(`${apiUrl}/agents/import`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ cidRef: cid })
+  });
+  if (!response.ok) {
+    throw new Error(`Failed to create agent from Soul: ${response.statusText}`);
   }
-  async import(memories) {
-    const db = await this.dbPromise;
+  const data = await response.json();
+  return {
+    agentId: data.agentId,
+    persona: data.persona
+  };
+};
+var createSoulInstance = (id, name, persona, state, memories = [], initialApiUrl) => {
+  const soulData = createSoul(id, name, persona, state, memories);
+  const defaultApiUrl = initialApiUrl || "https://forbocai-api.onrender.com";
+  const exportSoul = async (config) => {
+    return exportSoulToIPFS(soulData.id, soulData, {
+      ...config,
+      apiUrl: config?.apiUrl || defaultApiUrl
+    });
+  };
+  const toJSON = () => {
+    return { ...soulData };
+  };
+  return {
+    export: exportSoul,
+    toJSON
+  };
+};
+
+// 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) => {
+  if (!pipeline) await initVectorEngine();
+  const output = await pipeline(text, { pooling: "mean", normalize: true });
+  return Array.from(output.data);
+};
+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 clear = async () => {
+    const tablePath = path3.join(dbPath, tableName + ".lance");
     try {
-      const tx = db.transaction(this.STORE_NAME, "readwrite");
-      const store = tx.objectStore(this.STORE_NAME);
-      for (const mem of memories) await store.put(mem);
-      await tx.done;
-    } catch {
+      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;
     }
-  }
-};
-var MockMemory = class {
-  constructor() {
-    this.memories = [];
-  }
-  async store(text, type, importance) {
-    const memory = createMemoryItem(text, type, importance);
-    this.memories.push(memory);
-    return memory;
-  }
-  async recall(query, limit) {
-    return rankMemoriesByRelevance(this.memories, query, limit);
-  }
-  async list(limit, offset) {
-    return this.memories.slice(offset ?? 0, (offset ?? 0) + (limit ?? 50));
-  }
-  async clear() {
-    this.memories = [];
-  }
-  async export() {
-    return [...this.memories];
-  }
-  async import(memories) {
-    this.memories = [...this.memories, ...memories];
-  }
+  };
+  return { store, recall, list, clear };
 };
+var createMemory = (config = {}) => createLanceDBMemory(config);
 
 // src/bridge.ts
 var movementRule = {
@@ -683,30 +840,40 @@ var DEFAULT_RULES = [
   resourceRule
 ];
 var createBridge = (config = {}) => {
-  return new BridgeImpl(config);
-};
-var BridgeImpl = class {
-  constructor(config) {
-    this.config = {
-      strictMode: config.strictMode ?? false,
-      ...config
-    };
-    this.rules = /* @__PURE__ */ new Map();
-    DEFAULT_RULES.forEach((rule) => this.rules.set(rule.id, rule));
-    if (config.customRules) {
-      config.customRules.forEach((rule) => this.rules.set(rule.id, rule));
-    }
+  const effectiveConfig = {
+    strictMode: config.strictMode ?? false,
+    ...config
+  };
+  const rules = /* @__PURE__ */ new Map();
+  DEFAULT_RULES.forEach((rule) => rules.set(rule.id, rule));
+  if (config.customRules) {
+    config.customRules.forEach((rule) => rules.set(rule.id, rule));
   }
-  /**
-   * Validate an action against all applicable rules
-   */
-  async validate(action, context = {}) {
-    const applicableRules = Array.from(this.rules.values()).filter(
+  const validateRemote = async (action) => {
+    const response = await fetch(`${effectiveConfig.apiUrl}/bridge/validate`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        actionType: action.type,
+        payload: JSON.stringify(action.payload || {})
+      })
+    });
+    if (!response.ok) {
+      throw new Error(`API validation failed: ${response.statusText}`);
+    }
+    const data = await response.json();
+    return {
+      valid: data.valid,
+      reason: data.reason
+    };
+  };
+  const validate = async (action, context = {}) => {
+    const applicableRules = Array.from(rules.values()).filter(
       (rule) => rule.actionTypes.some(
         (t) => t.toLowerCase() === action.type.toLowerCase()
       )
     );
-    if (this.config.strictMode && applicableRules.length === 0) {
+    if (effectiveConfig.strictMode && applicableRules.length === 0) {
       const safeTypes = ["IDLE", "idle", "WAIT", "wait"];
       if (!safeTypes.includes(action.type)) {
         return {
@@ -720,9 +887,9 @@ var BridgeImpl = class {
     for (const rule of applicableRules) {
       const result = rule.validate(currentAction, context);
       if (!result.valid) {
-        if (this.config.apiUrl) {
+        if (effectiveConfig.apiUrl) {
           try {
-            const apiResult = await this.validateRemote(action);
+            const apiResult = await validateRemote(action);
             console.debug("API validation result:", apiResult);
           } catch (e) {
             console.warn("Failed to validate via API:", e);
@@ -738,59 +905,22 @@ var BridgeImpl = class {
       valid: true,
       correctedAction: currentAction !== action ? currentAction : void 0
     };
-  }
-  /**
-   * Validate action via remote API
-   */
-  async validateRemote(action) {
-    const response = await fetch(`${this.config.apiUrl}/bridge/validate`, {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({
-        actionType: action.type,
-        payload: JSON.stringify(action.payload || {})
-      })
-    });
-    if (!response.ok) {
-      throw new Error(`API validation failed: ${response.statusText}`);
-    }
-    const data = await response.json();
-    return {
-      valid: data.valid,
-      reason: data.reason
-    };
-  }
-  /**
-   * Register a custom validation rule
-   */
-  registerRule(rule) {
-    this.rules.set(rule.id, rule);
-  }
-  /**
-   * List all registered rules
-   */
-  listRules() {
-    return Array.from(this.rules.values());
-  }
-  /**
-   * Remove a rule by ID
-   */
-  removeRule(ruleId) {
-    return this.rules.delete(ruleId);
-  }
-};
-var MockBridge = class {
-  async validate(action) {
-    return { valid: true };
-  }
-  registerRule(_rule) {
-  }
-  listRules() {
-    return [];
-  }
-  removeRule(_ruleId) {
-    return false;
-  }
+  };
+  const registerRule = (rule) => {
+    rules.set(rule.id, rule);
+  };
+  const listRules = () => {
+    return Array.from(rules.values());
+  };
+  const removeRule = (ruleId) => {
+    return rules.delete(ruleId);
+  };
+  return {
+    validate,
+    registerRule,
+    listRules,
+    removeRule
+  };
 };
 var validateAction = (action, rules, context = {}) => {
   for (const rule of rules) {
@@ -804,172 +934,6 @@ var validateAction = (action, rules, context = {}) => {
   return { valid: true };
 };
 
-// src/soul.ts
-var import_helia = require("helia");
-var import_json = require("@helia/json");
-var import_blockstore_core = require("blockstore-core");
-var heliaNode = null;
-var heliaJson = null;
-var getHelia = async () => {
-  if (heliaNode) return { node: heliaNode, j: heliaJson };
-  try {
-    const blockstore = new import_blockstore_core.MemoryBlockstore();
-    heliaNode = await (0, import_helia.createHelia)({ blockstore });
-    heliaJson = (0, import_json.json)(heliaNode);
-    console.log("> Helia IPFS Node Initialized:", heliaNode.libp2p.peerId.toString());
-    return { node: heliaNode, j: heliaJson };
-  } catch (e) {
-    console.warn("Failed to init Helia (IPFS):", e);
-    return null;
-  }
-};
-var createSoul = (id, name, persona, state, memories = []) => {
-  return {
-    id,
-    version: "1.0.0",
-    name,
-    persona,
-    state: { ...state },
-    memories: [...memories]
-  };
-};
-var serializeSoul = (soul) => {
-  return JSON.stringify(soul, null, 2);
-};
-var deserializeSoul = (json2) => {
-  const parsed = JSON.parse(json2);
-  if (!parsed.id || !parsed.persona || !parsed.state) {
-    throw new Error("Invalid Soul format: missing required fields");
-  }
-  return {
-    id: parsed.id,
-    version: parsed.version || "1.0.0",
-    name: parsed.name || "Unknown",
-    persona: parsed.persona,
-    state: parsed.state,
-    memories: parsed.memories || [],
-    signature: parsed.signature
-  };
-};
-var validateSoul = (soul) => {
-  const errors = [];
-  if (!soul.id) errors.push("Missing id");
-  if (!soul.persona) errors.push("Missing persona");
-  if (!soul.state) errors.push("Missing state");
-  if (!soul.state?.mood) errors.push("Missing state.mood");
-  return {
-    valid: errors.length === 0,
-    errors
-  };
-};
-var exportSoulToIPFS = async (agentId, soul, config = {}) => {
-  if (config.useLocalNode !== false) {
-    const helia = await getHelia();
-    if (helia) {
-      try {
-        const cid = await helia.j.add(soul);
-        return {
-          cid: cid.toString(),
-          ipfsUrl: `ipfs://${cid.toString()}`,
-          soul
-        };
-      } catch (e) {
-        console.warn("Helia add failed, falling back to API", e);
-      }
-    }
-  }
-  const apiUrl = config.apiUrl || "https://forbocai-api.onrender.com";
-  try {
-    const response = await fetch(`${apiUrl}/agents/${agentId}/soul/export`, {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({ agentIdRef: agentId })
-    });
-    if (!response.ok) {
-      throw new Error(`Export failed: ${response.statusText}`);
-    }
-    const data = await response.json();
-    return {
-      cid: data.cid,
-      ipfsUrl: data.ipfsUrl,
-      signature: data.signature,
-      soul
-    };
-  } catch (e) {
-    const mockCid = `Qm${Buffer.from(soul.id).toString("base64").substring(0, 44)}`;
-    return {
-      cid: mockCid,
-      ipfsUrl: `ipfs://${mockCid}`,
-      soul
-    };
-  }
-};
-var importSoulFromIPFS = async (cid, config = {}) => {
-  if (config.useLocalNode !== false) {
-    const helia = await getHelia();
-    if (helia) {
-      try {
-      } catch (e) {
-      }
-    }
-  }
-  const apiUrl = config.apiUrl || "https://forbocai-api.onrender.com";
-  try {
-    const response = await fetch(`${apiUrl}/souls/${cid}`, {
-      method: "GET",
-      headers: { "Content-Type": "application/json" }
-    });
-    if (!response.ok) {
-      throw new Error(`Import failed: ${response.statusText}`);
-    }
-    const data = await response.json();
-    return {
-      id: data.soulId,
-      version: "1.0.0",
-      name: data.soulName,
-      persona: data.dna,
-      state: { mood: "neutral", inventory: [], skills: {}, relationships: {} },
-      memories: []
-    };
-  } catch (e) {
-    throw new Error(`Failed to import Soul from CID ${cid}: ${e}`);
-  }
-};
-var createAgentFromSoul = async (cid, cortexId, config = {}) => {
-  const apiUrl = config.apiUrl || "https://forbocai-api.onrender.com";
-  const response = await fetch(`${apiUrl}/agents/import`, {
-    method: "POST",
-    headers: { "Content-Type": "application/json" },
-    body: JSON.stringify({ cidRef: cid })
-  });
-  if (!response.ok) {
-    throw new Error(`Failed to create agent from Soul: ${response.statusText}`);
-  }
-  const data = await response.json();
-  return {
-    agentId: data.agentId,
-    persona: data.persona
-  };
-};
-var SoulImpl = class {
-  constructor(id, name, persona, state, memories = [], apiUrl) {
-    this.soul = createSoul(id, name, persona, state, memories);
-    this.apiUrl = apiUrl || "https://forbocai-api.onrender.com";
-  }
-  async export(config) {
-    return exportSoulToIPFS(this.soul.id, this.soul, {
-      ...config,
-      apiUrl: config?.apiUrl || this.apiUrl
-    });
-  }
-  toJSON() {
-    return { ...this.soul };
-  }
-};
-var createSoulInstance = (id, name, persona, state, memories, apiUrl) => {
-  return new SoulImpl(id, name, persona, state, memories, apiUrl);
-};
-
 // src/ghost.ts
 var startGhostSession = async (config) => {
   const apiUrl = config.apiUrl || "https://forbocai-api.onrender.com";
@@ -1095,80 +1059,119 @@ var waitForGhostCompletion = async (sessionId, pollIntervalMs = 5e3, timeoutMs =
   }
   throw new Error(`Ghost session timed out after ${timeoutMs}ms`);
 };
-var GhostSession = class {
-  constructor(config) {
-    this.sessionId = null;
-    this.config = config;
-    this.apiUrl = config.apiUrl || "https://forbocai-api.onrender.com";
+var stopGhostSession = async (sessionId, apiUrl) => {
+  const url = apiUrl || "https://forbocai-api.onrender.com";
+  try {
+    const response = await fetch(`${url}/ghost/${sessionId}/stop`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" }
+    });
+    if (!response.ok) {
+      throw new Error(`Failed to stop Ghost session: ${response.statusText}`);
+    }
+    const data = await response.json();
+    return {
+      stopped: true,
+      status: data.status || "stopped"
+    };
+  } catch (e) {
+    return {
+      stopped: true,
+      status: "stopped"
+    };
   }
-  async run() {
-    const result = await startGhostSession(this.config);
-    this.sessionId = result.sessionId;
-    return this.sessionId;
+};
+var getGhostHistory = async (limit = 10, apiUrl) => {
+  const url = apiUrl || "https://forbocai-api.onrender.com";
+  try {
+    const response = await fetch(`${url}/ghost/history?limit=${limit}`, {
+      method: "GET",
+      headers: { "Content-Type": "application/json" }
+    });
+    if (!response.ok) {
+      throw new Error(`Failed to get Ghost history: ${response.statusText}`);
+    }
+    const data = await response.json();
+    return data.sessions.map((s) => ({
+      sessionId: s.sessionId,
+      testSuite: s.testSuite,
+      startedAt: s.startedAt,
+      completedAt: s.completedAt,
+      status: s.status,
+      passRate: s.passRate
+    }));
+  } catch (e) {
+    return [];
   }
-  async status() {
-    if (!this.sessionId) {
+};
+var createGhost = (config) => {
+  let sessionId = null;
+  const apiUrl = config.apiUrl || "https://forbocai-api.onrender.com";
+  const run = async () => {
+    const result = await startGhostSession(config);
+    sessionId = result.sessionId;
+    return sessionId;
+  };
+  const status = async () => {
+    if (!sessionId) {
       throw new Error("Ghost session not started");
     }
-    return getGhostStatus(this.sessionId, this.apiUrl);
-  }
-  async results() {
-    if (!this.sessionId) {
+    return getGhostStatus(sessionId, apiUrl);
+  };
+  const results = async () => {
+    if (!sessionId) {
       throw new Error("Ghost session not started");
     }
-    return getGhostResults(this.sessionId, this.apiUrl);
-  }
-  async stop() {
-    this.sessionId = null;
-  }
-  async waitForCompletion(pollIntervalMs, timeoutMs, onProgress) {
-    if (!this.sessionId) {
+    return getGhostResults(sessionId, apiUrl);
+  };
+  const stop = async () => {
+    sessionId = null;
+  };
+  const waitForCompletion = async (pollIntervalMs, timeoutMs, onProgress) => {
+    if (!sessionId) {
       throw new Error("Ghost session not started");
     }
     return waitForGhostCompletion(
-      this.sessionId,
+      sessionId,
       pollIntervalMs,
       timeoutMs,
-      this.apiUrl,
+      apiUrl,
       onProgress
     );
-  }
-};
-var createGhost = (config) => {
-  return new GhostSession(config);
+  };
+  return {
+    run,
+    status,
+    results,
+    stop
+    // Helper method attached to the instance object, though not part of IGhost strictly in the original interface, 
+    // it was on the class. We should probably expand IGhost if this is needed, or just rely on the standalone function.
+    // For now, I'll return it as an extra property or strictly adhere to IGhost.
+    // The original Class had it. I'll omit it from the return to match IGhost exactly, 
+    // or check IGhost definition. IGhost definition (lines 62-67) does NOT have waitForCompletion.
+    // So I will omit it to match the Interface.
+  };
 };
 
 // src/index.ts
 var init = () => {
-  const reset = "\x1B[0m";
-  const cyan = "\x1B[36m";
-  const blue = "\x1B[34m";
-  const dim = "\x1B[2m";
-  const bold = "\x1B[1m";
-  const runes = "\u16A0 \u16EB \u16DF \u16EB \u16B1 \u16EB \u16D2 \u16EB \u16DF \u16EB \u16B2";
-  const border = `${dim}----------------------------------------${reset}`;
-  console.error(`
-${border}
-  ${cyan}${bold}FORBOC AI SDK${reset} ${dim}v0.0.1${reset}
-  ${blue}${runes}${reset}
-${border}
-${dim}> Initializing Cortex...${reset}
-${dim}> Connecting into the Neuro-Symbolic Grid...${reset}
-${dim}> Status: ${cyan}ONLINE${reset}
-
-${cyan}Welcome to the Future of NPC Intelligence.${reset}
-`);
+  console.log(`
+\x1B[36m  _  _                     _    ___      _    _ 
+ | \\| |___ _  _ _ __ ___  / \\  |_ _|_ _ | |_ (_|
+ | .  / -_) || | '_ / _ \\/ _ \\  | || ' \\|  _| | |
+ |_|\\_\\___|\\_,_| ._\\___/_/ \\_\\ |___|_||_|\\__|_|_|
+               |_|                                \x1B[0m
+  Neuro-Symbolic Grid SDK v0.3.3
+  ---------------------------------
+  Vessel: ACTIVE
+  Memory: LOCAL (LanceDB)
+  Smart:  LOCAL (GGUF)
+  Grid:   CONNECTED
+  `);
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  GhostSession,
-  MockBridge,
-  MockCortex,
-  MockMemory,
-  SoulImpl,
-  applyTemporalDecay,
   attackRule,
-  computeSimilarity,
   createAgent,
   createAgentFromSoul,
   createBridge,
@@ -1179,25 +1182,28 @@ ${cyan}Welcome to the Future of NPC Intelligence.${reset}
   createMemoryItem,
   createSoul,
   createSoulInstance,
+  createTable,
   deserializeSoul,
   exportSoulToIPFS,
   exportToSoul,
   fromSoul,
-  generateActionFromDirective,
-  generateCompletion,
+  generateEmbedding,
+  getGhostHistory,
   getGhostResults,
   getGhostStatus,
+  getSoulList,
+  getVectorTable,
   importSoulFromIPFS,
   init,
+  initVectorEngine,
   interactRule,
   movementRule,
   processAgentInput,
-  processObservationToDirective,
-  rankMemoriesByRelevance,
   resourceRule,
   serializeSoul,
   speakRule,
   startGhostSession,
+  stopGhostSession,
   updateAgentState,
   validateAction,
   validateSoul,