@aurora-foundation/obsidian-next 0.4.7 → 0.4.9

package/dist/chunk-DZI2OVN2.js

@@ -0,0 +1,516 @@
+import {
+  context
+} from "./chunk-EMBMLZFE.js";
+import {
+  bus
+} from "./chunk-WQM6FFSD.js";
+import {
+  db
+} from "./chunk-FNLWB54Z.js";
+
+// src/core/memory.ts
+import fs from "fs/promises";
+import path from "path";
+import os from "os";
+import { pipeline } from "@xenova/transformers";
+import chokidar from "chokidar";
+var MemoryManager = class {
+  initialized = false;
+  extractor = null;
+  watcher = null;
+  async init() {
+    if (this.initialized) return;
+    try {
+      this.extractor = await pipeline("feature-extraction", "Xenova/all-MiniLM-L6-v2");
+    } catch (e) {
+      bus.emitAgent({ type: "error", message: `[Memory] Embedding pipeline failed to initialize: ${e instanceof Error ? e.message : String(e)}` });
+    }
+    this.initialized = true;
+    this.startWatcher();
+  }
+  startWatcher() {
+    const memoryPath = path.join(os.homedir(), ".obsidian-next", "MEMORY.md");
+    if (this.watcher) return;
+    this.watcher = chokidar.watch(memoryPath, {
+      persistent: true,
+      ignoreInitial: true
+    });
+    this.watcher.on("change", async () => {
+      try {
+        await this.importFromMarkdown(memoryPath);
+      } catch (e) {
+      }
+    });
+  }
+  async importFromMarkdown(filePath) {
+    try {
+      const content = await fs.readFile(filePath, "utf-8");
+      const sections = content.split("## ").slice(1);
+      const typeMap = {
+        "User Preferences": "user_preference",
+        "Project Facts": "project_fact",
+        "Decision Log": "decision_log",
+        "Learned Patterns": "learned_pattern",
+        "Daily Summaries": "daily_summary"
+      };
+      for (const section of sections) {
+        const lines = section.split("\n");
+        const typeHeader = lines[0].trim();
+        const type = typeMap[typeHeader];
+        if (!type) continue;
+        const memoBlocks = section.split("### ").slice(1);
+        for (const block of memoBlocks) {
+          const blockLines = block.split("\n");
+          const key = blockLines[0].trim();
+          const memoContent = blockLines.slice(1).filter((l) => !l.trim().startsWith("*Last updated:")).join("\n").trim();
+          if (key && memoContent) {
+            await this.store(type, key, memoContent);
+          }
+        }
+      }
+    } catch {
+    }
+  }
+  async getEmbedding(text) {
+    await this.init();
+    if (!this.extractor) throw new Error("Embedding pipeline not initialized");
+    const output = await this.extractor(text, { pooling: "mean", normalize: true });
+    return Float32Array.from(output.data);
+  }
+  /**
+   * Store a memory/fact
+   */
+  async store(type, key, content) {
+    await this.init();
+    const sessionId = context.get().session_id;
+    try {
+      const embeddingArray = await this.getEmbedding(`${key}: ${content}`);
+      const embedding = Buffer.from(embeddingArray.buffer);
+      const transaction = db.getDb().transaction(() => {
+        const existing = db.getDb().prepare(`
+                    SELECT id FROM memos WHERE type = ? AND key = ?
+                `).get(type, key);
+        let memoId;
+        if (existing) {
+          db.getDb().prepare(`
+                        UPDATE memos SET content = ?, updated_at = strftime('%s', 'now'), session_id = ?
+                        WHERE id = ?
+                    `).run(content, sessionId, existing.id);
+          memoId = existing.id;
+        } else {
+          const result = db.getDb().prepare(`
+                        INSERT INTO memos (session_id, type, key, content)
+                        VALUES (?, ?, ?, ?)
+                    `).run(sessionId, type, key, content);
+          memoId = Number(result.lastInsertRowid);
+        }
+        db.getDb().prepare("DELETE FROM vec_memos WHERE rowid = ?").run(BigInt(memoId));
+        db.getDb().prepare(`
+                    INSERT INTO vec_memos (rowid, embedding)
+                    VALUES (?, ?)
+                `).run(BigInt(memoId), embedding);
+      });
+      transaction();
+      return true;
+    } catch (e) {
+      console.error("Failed to store memory:", e);
+      bus.emitAgent({ type: "error", message: `Memory Store Error: ${e instanceof Error ? e.message : String(e)}` });
+      return false;
+    }
+  }
+  /**
+   * Recall a specific memory by key
+   */
+  async recall(key) {
+    await this.init();
+    try {
+      const row = db.getDb().prepare(`
+                SELECT id, type, key, content, created_at, updated_at, access_count, last_accessed
+                FROM memos
+                WHERE key = ?
+                ORDER BY updated_at DESC
+                LIMIT 1
+            `).get(key);
+      if (!row) return null;
+      return {
+        id: row.id,
+        type: row.type,
+        key: row.key,
+        content: row.content,
+        created_at: new Date(row.created_at * 1e3).toISOString(),
+        updated_at: new Date(row.updated_at * 1e3).toISOString(),
+        access_count: row.access_count || 0,
+        last_accessed: row.last_accessed ? new Date(row.last_accessed * 1e3).toISOString() : void 0
+      };
+    } catch (e) {
+      bus.emitAgent({ type: "error", message: `[Memory] Recall failed for key "${key}": ${e instanceof Error ? e.message : String(e)}` });
+      return null;
+    }
+  }
+  /**
+   * Search memories by type or content (Semantic Search)
+   */
+  async search(query, type) {
+    await this.init();
+    try {
+      const embeddingArray = await this.getEmbedding(query);
+      const embedding = Buffer.from(embeddingArray.buffer);
+      let sql = `
+                SELECT m.id, m.type, m.key, m.content, m.created_at, m.updated_at,
+                       v.distance
+                FROM vec_memos v
+                JOIN memos m ON v.rowid = m.id
+                WHERE v.embedding MATCH ?
+                AND k = 20
+            `;
+      const params = [embedding];
+      if (type) {
+        sql = sql.replace("AND k = 20", "AND m.type = ? AND k = 20");
+        params.push(type);
+      }
+      const rows = db.getDb().prepare(sql).all(...params);
+      if (rows.length === 0) {
+        return this.keywordSearch(query, type);
+      }
+      return rows.map((row) => ({
+        id: row.id,
+        type: row.type,
+        key: row.key,
+        content: row.content,
+        created_at: new Date(row.created_at * 1e3).toISOString(),
+        updated_at: new Date(row.updated_at * 1e3).toISOString()
+      }));
+    } catch (e) {
+      bus.emitAgent({ type: "thought", content: `[Memory] Semantic search failed, falling back to keyword search.`, hidden: true });
+      return this.keywordSearch(query, type);
+    }
+  }
+  async keywordSearch(query, type) {
+    try {
+      let sql = `
+                SELECT id, type, key, content, created_at, updated_at
+                FROM memos
+                WHERE (key LIKE ? OR content LIKE ?)
+            `;
+      const params = [`%${query}%`, `%${query}%`];
+      if (type) {
+        sql += " AND type = ?";
+        params.push(type);
+      }
+      sql += " ORDER BY updated_at DESC LIMIT 20";
+      const rows = db.getDb().prepare(sql).all(...params);
+      return rows.map((row) => ({
+        id: row.id,
+        type: row.type,
+        key: row.key,
+        content: row.content,
+        created_at: new Date(row.created_at * 1e3).toISOString(),
+        updated_at: new Date(row.updated_at * 1e3).toISOString()
+      }));
+    } catch (e) {
+      return [];
+    }
+  }
+  /**
+   * Get all memories of a specific type
+   */
+  async getByType(type) {
+    await this.init();
+    try {
+      const rows = db.getDb().prepare(`
+                SELECT id, type, key, content, created_at, updated_at
+                FROM memos
+                WHERE type = ?
+                ORDER BY updated_at DESC
+            `).all(type);
+      return rows.map((row) => ({
+        id: row.id,
+        type: row.type,
+        key: row.key,
+        content: row.content,
+        created_at: new Date(row.created_at * 1e3).toISOString(),
+        updated_at: new Date(row.updated_at * 1e3).toISOString()
+      }));
+    } catch (e) {
+      bus.emitAgent({ type: "error", message: `[Memory] Failed to get memories by type "${type}": ${e instanceof Error ? e.message : String(e)}` });
+      return [];
+    }
+  }
+  /**
+   * Get user preferences summary for context injection
+   */
+  async getUserContext() {
+    await this.init();
+    try {
+      const prefs = await this.getByType("user_preference");
+      const facts = await this.getByType("project_fact");
+      if (prefs.length === 0 && facts.length === 0) {
+        return "";
+      }
+      const lines = ["[RECALL]"];
+      if (prefs.length > 0) {
+        for (const p of prefs.slice(0, 5)) {
+          lines.push(`${p.key}: ${p.content}`);
+        }
+      }
+      if (facts.length > 0) {
+        for (const f of facts.slice(0, 10)) {
+          lines.push(`${f.key}: ${f.content}`);
+        }
+      }
+      if (lines.length === 1) return "";
+      return lines.join("\n");
+    } catch (e) {
+      return "";
+    }
+  }
+  /**
+   * Delete a memory
+   */
+  async forget(key) {
+    await this.init();
+    try {
+      db.getDb().prepare("DELETE FROM memos WHERE key = ?").run(key);
+      return true;
+    } catch (e) {
+      bus.emitAgent({ type: "error", message: `[Memory] Failed to forget key "${key}": ${e instanceof Error ? e.message : String(e)}` });
+      return false;
+    }
+  }
+  /**
+   * Clear all memories (use with caution)
+   */
+  async clearAll() {
+    await this.init();
+    try {
+      db.getDb().prepare("DELETE FROM memos").run();
+      return true;
+    } catch (e) {
+      bus.emitAgent({ type: "error", message: `[Memory] Failed to clear all memories: ${e instanceof Error ? e.message : String(e)}` });
+      return false;
+    }
+  }
+  /**
+   * Get memory statistics
+   */
+  async getStats() {
+    await this.init();
+    try {
+      const total = db.getDb().prepare("SELECT COUNT(*) as count FROM memos").get();
+      const byTypeRows = db.getDb().prepare(`
+                SELECT type, COUNT(*) as count FROM memos GROUP BY type
+            `).all();
+      const byType = {};
+      for (const row of byTypeRows) {
+        byType[row.type] = row.count;
+      }
+      return {
+        total: total.count,
+        byType
+      };
+    } catch (e) {
+      return { total: 0, byType: {} };
+    }
+  }
+  /**
+   * Export all memories to a Markdown file for human readability
+   */
+  async exportToMarkdown() {
+    await this.init();
+    try {
+      const rows = db.getDb().prepare(`
+                SELECT type, key, content, updated_at 
+                FROM memos 
+                ORDER BY type, key
+            `).all();
+      if (rows.length === 0) {
+        return "No memories to export.";
+      }
+      let markdown = "# Obsidian Memory Bank\n\n";
+      markdown += `Generated on: ${(/* @__PURE__ */ new Date()).toLocaleString()}
+
+`;
+      const grouped = {};
+      for (const row of rows) {
+        if (!grouped[row.type]) grouped[row.type] = [];
+        grouped[row.type].push(row);
+      }
+      const typeNames = {
+        "user_preference": "User Preferences",
+        "project_fact": "Project Facts",
+        "decision_log": "Decision Log",
+        "learned_pattern": "Learned Patterns",
+        "daily_summary": "Daily Summaries"
+      };
+      for (const type of Object.keys(grouped)) {
+        markdown += `## ${typeNames[type] || type}
+
+`;
+        for (const memo of grouped[type]) {
+          markdown += `### ${memo.key}
+`;
+          markdown += `${memo.content}
+
+`;
+          markdown += `*Last updated: ${new Date(memo.updated_at * 1e3).toLocaleString()}*
+
+`;
+        }
+      }
+      const { config } = await import("./config-FJPPPYTY.js");
+      const cfg = await config.load();
+      const exportDir = path.join(os.homedir(), ".obsidian-next");
+      const exportPath = path.join(exportDir, "MEMORY.md");
+      await fs.mkdir(exportDir, { recursive: true });
+      await fs.writeFile(exportPath, markdown, "utf-8");
+      return exportPath;
+    } catch (error) {
+      bus.emitAgent({ type: "error", message: `[Memory] Export failed: ${error.message}` });
+      throw new Error(`Failed to export memory: ${error.message}`);
+    }
+  }
+  // ==================== Memory Graph Methods ====================
+  /**
+   * Add a relationship between two memos
+   */
+  async addRelation(sourceKey, targetKey, relationType, strength = 1) {
+    await this.init();
+    try {
+      const source = await this.recall(sourceKey);
+      const target = await this.recall(targetKey);
+      if (!source || !target) {
+        return false;
+      }
+      db.getDb().prepare(`
+                INSERT OR REPLACE INTO memo_relations (source_id, target_id, relation_type, strength)
+                VALUES (?, ?, ?, ?)
+            `).run(source.id, target.id, relationType, Math.max(0, Math.min(1, strength)));
+      return true;
+    } catch (e) {
+      bus.emitAgent({ type: "error", message: `[Memory] Failed to add relation: ${e instanceof Error ? e.message : String(e)}` });
+      return false;
+    }
+  }
+  /**
+   * Get all relationships for a memo
+   */
+  async getRelations(key) {
+    await this.init();
+    try {
+      const memo = await this.recall(key);
+      if (!memo) return [];
+      const rows = db.getDb().prepare(`
+                SELECT id, source_id, target_id, relation_type, strength, created_at
+                FROM memo_relations
+                WHERE source_id = ? OR target_id = ?
+            `).all(memo.id, memo.id);
+      return rows.map((row) => ({
+        id: row.id,
+        sourceId: row.source_id,
+        targetId: row.target_id,
+        relationType: row.relation_type,
+        strength: row.strength,
+        createdAt: new Date(row.created_at * 1e3).toISOString()
+      }));
+    } catch (e) {
+      return [];
+    }
+  }
+  /**
+   * Get related memos with their relationships
+   */
+  async getRelatedMemos(key) {
+    await this.init();
+    try {
+      const memo = await this.recall(key);
+      if (!memo) return [];
+      const rows = db.getDb().prepare(`
+                SELECT 
+                    m.id, m.type, m.key, m.content, m.created_at, m.updated_at,
+                    m.access_count, m.last_accessed,
+                    r.id as rel_id, r.source_id, r.target_id, r.relation_type, r.strength, r.created_at as rel_created
+                FROM memo_relations r
+                JOIN memos m ON (
+                    (r.source_id = ? AND r.target_id = m.id) OR
+                    (r.target_id = ? AND r.source_id = m.id)
+                )
+                WHERE (r.source_id = ? OR r.target_id = ?)
+                ORDER BY r.strength DESC
+            `).all(memo.id, memo.id, memo.id, memo.id);
+      return rows.map((row) => ({
+        memo: {
+          id: row.id,
+          type: row.type,
+          key: row.key,
+          content: row.content,
+          created_at: new Date(row.created_at * 1e3).toISOString(),
+          updated_at: new Date(row.updated_at * 1e3).toISOString(),
+          access_count: row.access_count || 0,
+          last_accessed: row.last_accessed ? new Date(row.last_accessed * 1e3).toISOString() : void 0
+        },
+        relation: {
+          id: row.rel_id,
+          sourceId: row.source_id,
+          targetId: row.target_id,
+          relationType: row.relation_type,
+          strength: row.strength,
+          createdAt: new Date(row.rel_created * 1e3).toISOString()
+        }
+      }));
+    } catch (e) {
+      return [];
+    }
+  }
+  /**
+   * Calculate relevance score with temporal decay
+   * Score decays exponentially based on time since last access and access frequency
+   */
+  getRelevanceScore(memo) {
+    const now = Date.now();
+    const lastAccessed = memo.last_accessed ? new Date(memo.last_accessed).getTime() : now;
+    const accessCount = memo.access_count || 1;
+    const halfLife = 7 * 24 * 60 * 60 * 1e3;
+    const timeSinceAccess = now - lastAccessed;
+    const decayFactor = Math.pow(0.5, timeSinceAccess / halfLife);
+    const frequencyBoost = 1 + Math.log10(accessCount + 1) * 0.2;
+    return decayFactor * frequencyBoost;
+  }
+  /**
+   * Update access stats for a memo (call when memo is retrieved/used)
+   */
+  async updateAccessStats(key) {
+    await this.init();
+    try {
+      db.getDb().prepare(`
+                UPDATE memos 
+                SET access_count = COALESCE(access_count, 0) + 1,
+                    last_accessed = strftime('%s', 'now')
+                WHERE key = ?
+            `).run(key);
+    } catch (e) {
+    }
+  }
+  /**
+   * Search with relationship awareness - includes related memos in results
+   */
+  async searchWithRelations(query, type) {
+    await this.init();
+    const baseResults = await this.search(query, type);
+    const enriched = await Promise.all(baseResults.map(async (memo) => {
+      await this.updateAccessStats(memo.key);
+      const freshMemo = await this.recall(memo.key);
+      const memoWithStats = freshMemo || memo;
+      const score = this.getRelevanceScore(memoWithStats);
+      const relatedResults = await this.getRelatedMemos(memo.key);
+      const related = relatedResults.map((r) => r.memo);
+      return { memo: memoWithStats, score, related };
+    }));
+    return enriched.sort((a, b) => b.score - a.score);
+  }
+};
+var memory = new MemoryManager();
+
+export {
+  MemoryManager,
+  memory
+};