@akashabot/openclaw-memory-offline-core 0.1.1 → 0.3.0

package/dist/index.d.ts

@@ -18,6 +18,22 @@ export type MemItem = {
     text: string;
     tags: string | null;
     meta: string | null;
+    entity_id: string | null;
+    process_id: string | null;
+    session_id: string | null;
+};
+export type Fact = {
+    id: string;
+    created_at: number;
+    subject: string;
+    predicate: string;
+    object: string;
+    confidence: number;
+    source_item_id: string | null;
+    entity_id: string | null;
+};
+export type InsertFactInput = Omit<Fact, 'created_at'> & {
+    created_at?: number;
 };
 export type InsertItemInput = Omit<MemItem, 'created_at'> & {
     created_at?: number;
@@ -32,6 +48,11 @@ export type HybridResult = LexicalResult & {
 };
 export declare function openDb(dbPath: string): Database.Database;
 export declare function initSchema(db: Database.Database): void;
+/**
+ * Run migrations for existing databases that lack Phase 1 columns.
+ * Safe to call on every startup - will only add missing columns.
+ */
+export declare function runMigrations(db: Database.Database): void;
 /**
  * Minimal escaping for FTS5 queries.
  *
@@ -60,3 +81,88 @@ export declare function hybridSearch(db: Database.Database, cfg: MemConfig, quer
     candidates?: number;
     semanticWeight?: number;
 }): Promise<HybridResult[]>;
+export type FilterOpts = {
+    entity_id?: string | null;
+    process_id?: string | null;
+    session_id?: string | null;
+};
+/**
+ * Filter hybrid search results by attribution/session fields.
+ */
+export declare function filterResults(results: HybridResult[], opts: FilterOpts): HybridResult[];
+/**
+ * Hybrid search with built-in filtering (more efficient than filter + hybridSearch).
+ */
+export declare function hybridSearchFiltered(db: Database.Database, cfg: MemConfig, query: string, opts?: {
+    topK?: number;
+    candidates?: number;
+    semanticWeight?: number;
+    filter?: FilterOpts;
+}): Promise<HybridResult[]>;
+/**
+ * Get all memories for a specific entity (e.g., "what did Loïc tell me?").
+ */
+export declare function getMemoriesByEntity(db: Database.Database, entity_id: string, limit?: number): MemItem[];
+/**
+ * Get all memories for a specific session/conversation.
+ */
+export declare function getMemoriesBySession(db: Database.Database, session_id: string, limit?: number): MemItem[];
+/**
+ * Get all memories captured by a specific process/agent.
+ */
+export declare function getMemoriesByProcess(db: Database.Database, process_id: string, limit?: number): MemItem[];
+/**
+ * List distinct entity_ids in the database.
+ */
+export declare function listEntities(db: Database.Database): string[];
+/**
+ * List distinct session_ids in the database.
+ */
+export declare function listSessions(db: Database.Database): string[];
+/**
+ * Insert a new fact into the database.
+ */
+export declare function insertFact(db: Database.Database, input: InsertFactInput): Fact;
+/**
+ * Get all facts about a specific subject.
+ */
+export declare function getFactsBySubject(db: Database.Database, subject: string, limit?: number): Fact[];
+/**
+ * Get all facts with a specific predicate.
+ */
+export declare function getFactsByPredicate(db: Database.Database, predicate: string, limit?: number): Fact[];
+/**
+ * Search facts by subject, predicate, or object (simple LIKE search).
+ */
+export declare function searchFacts(db: Database.Database, query: string, limit?: number): Fact[];
+/**
+ * Get all facts (optionally filtered by entity_id).
+ */
+export declare function getAllFacts(db: Database.Database, entityId?: string, limit?: number): Fact[];
+/**
+ * List distinct subjects in the facts table.
+ */
+export declare function listSubjects(db: Database.Database): string[];
+/**
+ * List distinct predicates in the facts table.
+ */
+export declare function listPredicates(db: Database.Database): string[];
+/**
+ * Delete a fact by ID.
+ */
+export declare function deleteFact(db: Database.Database, id: string): boolean;
+/**
+ * Delete all facts derived from a specific memory item.
+ */
+export declare function deleteFactsBySourceItem(db: Database.Database, sourceItemId: string): number;
+/**
+ * Simple pattern-based fact extraction.
+ * Looks for common patterns like "X works at Y", "X prefers Y", etc.
+ * Returns an array of potential facts (not inserted yet).
+ */
+export declare function extractFactsSimple(text: string, entityId?: string): Array<{
+    subject: string;
+    predicate: string;
+    object: string;
+    confidence: number;
+}>;

package/dist/index.js

@@ -6,52 +6,103 @@ export function openDb(dbPath) {
     return db;
 }
 export function initSchema(db) {
-    db.exec(`
-    CREATE TABLE IF NOT EXISTS items (
-      id TEXT PRIMARY KEY,
-      created_at INTEGER NOT NULL,
-      source TEXT,
-      source_id TEXT,
-      title TEXT,
-      text TEXT NOT NULL,
-      tags TEXT,
-      meta TEXT
-    );
-
-    CREATE VIRTUAL TABLE IF NOT EXISTS items_fts USING fts5(
-      title,
-      text,
-      tags,
-      content='items',
-      content_rowid='rowid'
-    );
-
-    -- Keep the FTS index in sync with items.
-    CREATE TRIGGER IF NOT EXISTS items_ai AFTER INSERT ON items BEGIN
-      INSERT INTO items_fts(rowid, title, text, tags)
-      VALUES (new.rowid, new.title, new.text, new.tags);
-    END;
-
-    CREATE TRIGGER IF NOT EXISTS items_ad AFTER DELETE ON items BEGIN
-      INSERT INTO items_fts(items_fts, rowid, title, text, tags)
-      VALUES('delete', old.rowid, old.title, old.text, old.tags);
-    END;
-
-    CREATE TRIGGER IF NOT EXISTS items_au AFTER UPDATE ON items BEGIN
-      INSERT INTO items_fts(items_fts, rowid, title, text, tags)
-      VALUES('delete', old.rowid, old.title, old.text, old.tags);
-      INSERT INTO items_fts(rowid, title, text, tags)
-      VALUES (new.rowid, new.title, new.text, new.tags);
-    END;
-
-    CREATE TABLE IF NOT EXISTS embeddings (
-      item_id TEXT PRIMARY KEY,
-      model TEXT NOT NULL,
-      dims INTEGER NOT NULL,
-      vector BLOB NOT NULL,
-      updated_at INTEGER NOT NULL,
-      FOREIGN KEY(item_id) REFERENCES items(id)
-    );
+    db.exec(`
+    CREATE TABLE IF NOT EXISTS items (
+      id TEXT PRIMARY KEY,
+      created_at INTEGER NOT NULL,
+      source TEXT,
+      source_id TEXT,
+      title TEXT,
+      text TEXT NOT NULL,
+      tags TEXT,
+      meta TEXT,
+      -- Phase 1: Attribution & Session
+      entity_id TEXT,
+      process_id TEXT,
+      session_id TEXT
+    );
+
+    CREATE VIRTUAL TABLE IF NOT EXISTS items_fts USING fts5(
+      title,
+      text,
+      tags,
+      content='items',
+      content_rowid='rowid'
+    );
+
+    -- Keep the FTS index in sync with items.
+    CREATE TRIGGER IF NOT EXISTS items_ai AFTER INSERT ON items BEGIN
+      INSERT INTO items_fts(rowid, title, text, tags)
+      VALUES (new.rowid, new.title, new.text, new.tags);
+    END;
+
+    CREATE TRIGGER IF NOT EXISTS items_ad AFTER DELETE ON items BEGIN
+      INSERT INTO items_fts(items_fts, rowid, title, text, tags)
+      VALUES('delete', old.rowid, old.title, old.text, old.tags);
+    END;
+
+    CREATE TRIGGER IF NOT EXISTS items_au AFTER UPDATE ON items BEGIN
+      INSERT INTO items_fts(items_fts, rowid, title, text, tags)
+      VALUES('delete', old.rowid, old.title, old.text, old.tags);
+      INSERT INTO items_fts(rowid, title, text, tags)
+      VALUES (new.rowid, new.title, new.text, new.tags);
+    END;
+
+    CREATE TABLE IF NOT EXISTS embeddings (
+      item_id TEXT PRIMARY KEY,
+      model TEXT NOT NULL,
+      dims INTEGER NOT NULL,
+      vector BLOB NOT NULL,
+      updated_at INTEGER NOT NULL,
+      FOREIGN KEY(item_id) REFERENCES items(id)
+    );
+
+    -- Phase 2: Structured Facts Table
+    CREATE TABLE IF NOT EXISTS facts (
+      id TEXT PRIMARY KEY,
+      created_at INTEGER NOT NULL,
+      subject TEXT NOT NULL,
+      predicate TEXT NOT NULL,
+      object TEXT NOT NULL,
+      confidence REAL NOT NULL DEFAULT 0.5,
+      source_item_id TEXT,
+      entity_id TEXT,
+      FOREIGN KEY(source_item_id) REFERENCES items(id)
+    );
+
+    -- Indexes for Phase 1: Attribution & Session filtering
+    CREATE INDEX IF NOT EXISTS idx_items_entity_id ON items(entity_id);
+    CREATE INDEX IF NOT EXISTS idx_items_process_id ON items(process_id);
+    CREATE INDEX IF NOT EXISTS idx_items_session_id ON items(session_id);
+
+    -- Indexes for Phase 2: Facts queries
+    CREATE INDEX IF NOT EXISTS idx_facts_subject ON facts(subject);
+    CREATE INDEX IF NOT EXISTS idx_facts_predicate ON facts(predicate);
+    CREATE INDEX IF NOT EXISTS idx_facts_entity_id ON facts(entity_id);
+  `);
+}
+/**
+ * Run migrations for existing databases that lack Phase 1 columns.
+ * Safe to call on every startup - will only add missing columns.
+ */
+export function runMigrations(db) {
+    const cols = db.prepare("PRAGMA table_info(items)").all();
+    const existing = new Set(cols.map(c => c.name));
+    const migrations = [
+        { col: 'entity_id', sql: 'ALTER TABLE items ADD COLUMN entity_id TEXT' },
+        { col: 'process_id', sql: 'ALTER TABLE items ADD COLUMN process_id TEXT' },
+        { col: 'session_id', sql: 'ALTER TABLE items ADD COLUMN session_id TEXT' },
+    ];
+    for (const m of migrations) {
+        if (!existing.has(m.col)) {
+            db.exec(m.sql);
+        }
+    }
+    // Ensure indexes exist (safe to repeat)
+    db.exec(`
+    CREATE INDEX IF NOT EXISTS idx_items_entity_id ON items(entity_id);
+    CREATE INDEX IF NOT EXISTS idx_items_process_id ON items(process_id);
+    CREATE INDEX IF NOT EXISTS idx_items_session_id ON items(session_id);
   `);
 }
 /**
@@ -88,9 +139,9 @@ export function searchItems(db, query, limit = 10) {
 }
 export function insertItem(db, input) {
     const now = input.created_at ?? Date.now();
-    const stmt = db.prepare(`
-    INSERT INTO items (id, created_at, source, source_id, title, text, tags, meta)
-    VALUES (@id, @created_at, @source, @source_id, @title, @text, @tags, @meta)
+    const stmt = db.prepare(`
+    INSERT INTO items (id, created_at, source, source_id, title, text, tags, meta, entity_id, process_id, session_id)
+    VALUES (@id, @created_at, @source, @source_id, @title, @text, @tags, @meta, @entity_id, @process_id, @session_id)
   `);
     stmt.run({
         id: input.id,
@@ -101,6 +152,9 @@ export function insertItem(db, input) {
         text: input.text,
         tags: input.tags ?? null,
         meta: input.meta ?? null,
+        entity_id: input.entity_id ?? null,
+        process_id: input.process_id ?? null,
+        session_id: input.session_id ?? null,
     });
     return {
         id: input.id,
@@ -111,26 +165,32 @@ export function insertItem(db, input) {
         text: input.text,
         tags: input.tags ?? null,
         meta: input.meta ?? null,
+        entity_id: input.entity_id ?? null,
+        process_id: input.process_id ?? null,
+        session_id: input.session_id ?? null,
     };
 }
 export function lexicalSearch(db, query, limit = 10) {
     const rows = db
-        .prepare(`
-      SELECT
-        i.id,
-        i.created_at,
-        i.source,
-        i.source_id,
-        i.title,
-        i.text,
-        i.tags,
-        i.meta,
-        bm25(items_fts) AS bm25
-      FROM items_fts
-      JOIN items i ON i.rowid = items_fts.rowid
-      WHERE items_fts MATCH ?
-      ORDER BY bm25 ASC
-      LIMIT ?
+        .prepare(`
+      SELECT
+        i.id,
+        i.created_at,
+        i.source,
+        i.source_id,
+        i.title,
+        i.text,
+        i.tags,
+        i.meta,
+        i.entity_id,
+        i.process_id,
+        i.session_id,
+        bm25(items_fts) AS bm25
+      FROM items_fts
+      JOIN items i ON i.rowid = items_fts.rowid
+      WHERE items_fts MATCH ?
+      ORDER BY bm25 ASC
+      LIMIT ?
     `)
         .all(query, limit);
     return rows.map((r) => ({
@@ -143,6 +203,9 @@ export function lexicalSearch(db, query, limit = 10) {
             text: r.text,
             tags: r.tags,
             meta: r.meta,
+            entity_id: r.entity_id,
+            process_id: r.process_id,
+            session_id: r.session_id,
         },
         // bm25: lower is better; flip sign so higher is better
         lexicalScore: -Number(r.bm25),
@@ -243,12 +306,12 @@ async function getOrCreateItemEmbedding(db, cfg, itemId, text) {
     try {
         const emb = await fetchEmbedding(cfg, text);
         const blob = vectorToBlob(emb.vector);
-        db.prepare(`INSERT INTO embeddings (item_id, model, dims, vector, updated_at)
-       VALUES (?, ?, ?, ?, ?)
-       ON CONFLICT(item_id) DO UPDATE SET
-         model=excluded.model,
-         dims=excluded.dims,
-         vector=excluded.vector,
+        db.prepare(`INSERT INTO embeddings (item_id, model, dims, vector, updated_at)
+       VALUES (?, ?, ?, ?, ?)
+       ON CONFLICT(item_id) DO UPDATE SET
+         model=excluded.model,
+         dims=excluded.dims,
+         vector=excluded.vector,
          updated_at=excluded.updated_at`).run(itemId, emb.model, emb.dims, blob, Date.now());
         return emb;
     }
@@ -263,9 +326,9 @@ export async function hybridSearch(db, cfg, query, opts) {
     // Candidates: lexical hits + recents (merged).
     const lexHits = lexicalSearch(db, query, candidates);
     const recentRows = db
-        .prepare(`SELECT id, created_at, source, source_id, title, text, tags, meta
-       FROM items
-       ORDER BY created_at DESC
+        .prepare(`SELECT id, created_at, source, source_id, title, text, tags, meta, entity_id, process_id, session_id
+       FROM items
+       ORDER BY created_at DESC
        LIMIT ?`)
         .all(candidates);
     const recent = recentRows.map((r) => ({
@@ -278,6 +341,9 @@ export async function hybridSearch(db, cfg, query, opts) {
             text: r.text,
             tags: r.tags,
             meta: r.meta,
+            entity_id: r.entity_id,
+            process_id: r.process_id,
+            session_id: r.session_id,
         },
         lexicalScore: 0,
     }));
@@ -316,3 +382,335 @@ export async function hybridSearch(db, cfg, query, opts) {
     out.sort((a, b) => b.score - a.score);
     return out.slice(0, topK);
 }
+/**
+ * Filter hybrid search results by attribution/session fields.
+ */
+export function filterResults(results, opts) {
+    return results.filter(r => {
+        if (opts.entity_id !== undefined && r.item.entity_id !== opts.entity_id)
+            return false;
+        if (opts.process_id !== undefined && r.item.process_id !== opts.process_id)
+            return false;
+        if (opts.session_id !== undefined && r.item.session_id !== opts.session_id)
+            return false;
+        return true;
+    });
+}
+/**
+ * Hybrid search with built-in filtering (more efficient than filter + hybridSearch).
+ */
+export async function hybridSearchFiltered(db, cfg, query, opts) {
+    const results = await hybridSearch(db, cfg, query, opts);
+    if (!opts?.filter)
+        return results;
+    return filterResults(results, opts.filter);
+}
+/**
+ * Get all memories for a specific entity (e.g., "what did Loïc tell me?").
+ */
+export function getMemoriesByEntity(db, entity_id, limit = 50) {
+    const rows = db
+        .prepare(`SELECT id, created_at, source, source_id, title, text, tags, meta, entity_id, process_id, session_id
+       FROM items
+       WHERE entity_id = ?
+       ORDER BY created_at DESC
+       LIMIT ?`)
+        .all(entity_id, limit);
+    return rows.map(r => ({
+        id: r.id,
+        created_at: r.created_at,
+        source: r.source,
+        source_id: r.source_id,
+        title: r.title,
+        text: r.text,
+        tags: r.tags,
+        meta: r.meta,
+        entity_id: r.entity_id,
+        process_id: r.process_id,
+        session_id: r.session_id,
+    }));
+}
+/**
+ * Get all memories for a specific session/conversation.
+ */
+export function getMemoriesBySession(db, session_id, limit = 100) {
+    const rows = db
+        .prepare(`SELECT id, created_at, source, source_id, title, text, tags, meta, entity_id, process_id, session_id
+       FROM items
+       WHERE session_id = ?
+       ORDER BY created_at ASC
+       LIMIT ?`)
+        .all(session_id, limit);
+    return rows.map(r => ({
+        id: r.id,
+        created_at: r.created_at,
+        source: r.source,
+        source_id: r.source_id,
+        title: r.title,
+        text: r.text,
+        tags: r.tags,
+        meta: r.meta,
+        entity_id: r.entity_id,
+        process_id: r.process_id,
+        session_id: r.session_id,
+    }));
+}
+/**
+ * Get all memories captured by a specific process/agent.
+ */
+export function getMemoriesByProcess(db, process_id, limit = 100) {
+    const rows = db
+        .prepare(`SELECT id, created_at, source, source_id, title, text, tags, meta, entity_id, process_id, session_id
+       FROM items
+       WHERE process_id = ?
+       ORDER BY created_at DESC
+       LIMIT ?`)
+        .all(process_id, limit);
+    return rows.map(r => ({
+        id: r.id,
+        created_at: r.created_at,
+        source: r.source,
+        source_id: r.source_id,
+        title: r.title,
+        text: r.text,
+        tags: r.tags,
+        meta: r.meta,
+        entity_id: r.entity_id,
+        process_id: r.process_id,
+        session_id: r.session_id,
+    }));
+}
+/**
+ * List distinct entity_ids in the database.
+ */
+export function listEntities(db) {
+    const rows = db
+        .prepare(`SELECT DISTINCT entity_id FROM items WHERE entity_id IS NOT NULL ORDER BY entity_id`)
+        .all();
+    return rows.map(r => r.entity_id);
+}
+/**
+ * List distinct session_ids in the database.
+ */
+export function listSessions(db) {
+    const rows = db
+        .prepare(`SELECT DISTINCT session_id FROM items WHERE session_id IS NOT NULL ORDER BY session_id`)
+        .all();
+    return rows.map(r => r.session_id);
+}
+// ============================================================================
+// Phase 2: Structured Facts
+// ============================================================================
+/**
+ * Insert a new fact into the database.
+ */
+export function insertFact(db, input) {
+    const stmt = db.prepare(`
+    INSERT INTO facts (id, created_at, subject, predicate, object, confidence, source_item_id, entity_id)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+  `);
+    const created_at = input.created_at ?? Date.now();
+    stmt.run(input.id, created_at, input.subject, input.predicate, input.object, input.confidence, input.source_item_id ?? null, input.entity_id ?? null);
+    return { ...input, created_at };
+}
+/**
+ * Get all facts about a specific subject.
+ */
+export function getFactsBySubject(db, subject, limit = 100) {
+    const rows = db
+        .prepare(`SELECT id, created_at, subject, predicate, object, confidence, source_item_id, entity_id
+       FROM facts
+       WHERE subject = ?
+       ORDER BY confidence DESC, created_at DESC
+       LIMIT ?`)
+        .all(subject, limit);
+    return rows.map(r => ({
+        id: r.id,
+        created_at: r.created_at,
+        subject: r.subject,
+        predicate: r.predicate,
+        object: r.object,
+        confidence: r.confidence,
+        source_item_id: r.source_item_id,
+        entity_id: r.entity_id,
+    }));
+}
+/**
+ * Get all facts with a specific predicate.
+ */
+export function getFactsByPredicate(db, predicate, limit = 100) {
+    const rows = db
+        .prepare(`SELECT id, created_at, subject, predicate, object, confidence, source_item_id, entity_id
+       FROM facts
+       WHERE predicate = ?
+       ORDER BY confidence DESC, created_at DESC
+       LIMIT ?`)
+        .all(predicate, limit);
+    return rows.map(r => ({
+        id: r.id,
+        created_at: r.created_at,
+        subject: r.subject,
+        predicate: r.predicate,
+        object: r.object,
+        confidence: r.confidence,
+        source_item_id: r.source_item_id,
+        entity_id: r.entity_id,
+    }));
+}
+/**
+ * Search facts by subject, predicate, or object (simple LIKE search).
+ */
+export function searchFacts(db, query, limit = 50) {
+    const pattern = `%${query}%`;
+    const rows = db
+        .prepare(`SELECT id, created_at, subject, predicate, object, confidence, source_item_id, entity_id
+       FROM facts
+       WHERE subject LIKE ? OR predicate LIKE ? OR object LIKE ?
+       ORDER BY confidence DESC, created_at DESC
+       LIMIT ?`)
+        .all(pattern, pattern, pattern, limit);
+    return rows.map(r => ({
+        id: r.id,
+        created_at: r.created_at,
+        subject: r.subject,
+        predicate: r.predicate,
+        object: r.object,
+        confidence: r.confidence,
+        source_item_id: r.source_item_id,
+        entity_id: r.entity_id,
+    }));
+}
+/**
+ * Get all facts (optionally filtered by entity_id).
+ */
+export function getAllFacts(db, entityId, limit = 100) {
+    let rows;
+    if (entityId) {
+        rows = db
+            .prepare(`SELECT id, created_at, subject, predicate, object, confidence, source_item_id, entity_id
+         FROM facts
+         WHERE entity_id = ?
+         ORDER BY created_at DESC
+         LIMIT ?`)
+            .all(entityId, limit);
+    }
+    else {
+        rows = db
+            .prepare(`SELECT id, created_at, subject, predicate, object, confidence, source_item_id, entity_id
+         FROM facts
+         ORDER BY created_at DESC
+         LIMIT ?`)
+            .all(limit);
+    }
+    return rows.map(r => ({
+        id: r.id,
+        created_at: r.created_at,
+        subject: r.subject,
+        predicate: r.predicate,
+        object: r.object,
+        confidence: r.confidence,
+        source_item_id: r.source_item_id,
+        entity_id: r.entity_id,
+    }));
+}
+/**
+ * List distinct subjects in the facts table.
+ */
+export function listSubjects(db) {
+    const rows = db
+        .prepare(`SELECT DISTINCT subject FROM facts ORDER BY subject`)
+        .all();
+    return rows.map(r => r.subject);
+}
+/**
+ * List distinct predicates in the facts table.
+ */
+export function listPredicates(db) {
+    const rows = db
+        .prepare(`SELECT DISTINCT predicate FROM facts ORDER BY predicate`)
+        .all();
+    return rows.map(r => r.predicate);
+}
+/**
+ * Delete a fact by ID.
+ */
+export function deleteFact(db, id) {
+    const stmt = db.prepare('DELETE FROM facts WHERE id = ?');
+    const result = stmt.run(id);
+    return (result.changes ?? 0) > 0;
+}
+/**
+ * Delete all facts derived from a specific memory item.
+ */
+export function deleteFactsBySourceItem(db, sourceItemId) {
+    const stmt = db.prepare('DELETE FROM facts WHERE source_item_id = ?');
+    const result = stmt.run(sourceItemId);
+    return result.changes ?? 0;
+}
+/**
+ * Simple pattern-based fact extraction.
+ * Looks for common patterns like "X works at Y", "X prefers Y", etc.
+ * Returns an array of potential facts (not inserted yet).
+ */
+export function extractFactsSimple(text, entityId) {
+    const facts = [];
+    const lower = text.toLowerCase();
+    // Pattern: "X works at Y" / "X travaille chez Y"
+    const workPatterns = [
+        /(\w+)\s+(?:works at|travaille chez|works for|work at)\s+([\w\s]+?)(?:\.|,|$)/gi,
+    ];
+    for (const pattern of workPatterns) {
+        let match;
+        while ((match = pattern.exec(text)) !== null) {
+            facts.push({
+                subject: match[1].trim(),
+                predicate: 'works_at',
+                object: match[2].trim(),
+                confidence: 0.7,
+            });
+        }
+    }
+    // Pattern: "X prefers Y" / "X préfère Y"
+    const preferPatterns = [
+        /(\w+)\s+(?:prefers?|préfère)\s+([\w\s]+?)(?:\.|,|$)/gi,
+    ];
+    for (const pattern of preferPatterns) {
+        let match;
+        while ((match = pattern.exec(text)) !== null) {
+            facts.push({
+                subject: match[1].trim(),
+                predicate: 'prefers',
+                object: match[2].trim(),
+                confidence: 0.8,
+            });
+        }
+    }
+    // Pattern: "X is Y" / "X est Y"
+    const isPatterns = [
+        /(\w+)\s+(?:is|est)\s+(?:a |an |un |une )?([\w\s]+?)(?:\.|,|$)/gi,
+    ];
+    for (const pattern of isPatterns) {
+        let match;
+        while ((match = pattern.exec(text)) !== null) {
+            const subject = match[1].trim();
+            // Skip common false positives
+            if (['it', 'this', 'that', 'ce', 'il', 'elle', 'cette'].includes(subject.toLowerCase()))
+                continue;
+            facts.push({
+                subject,
+                predicate: 'is',
+                object: match[2].trim(),
+                confidence: 0.6,
+            });
+        }
+    }
+    // Dedupe by subject+predicate+object
+    const seen = new Set();
+    return facts.filter(f => {
+        const key = `${f.subject}|${f.predicate}|${f.object}`.toLowerCase();
+        if (seen.has(key))
+            return false;
+        seen.add(key);
+        return true;
+    });
+}

package/package.json

@@ -1,15 +1,23 @@
-{
-  "name": "@akashabot/openclaw-memory-offline-core",
-  "version": "0.1.1",
-  "type": "module",
-  "main": "./dist/index.js",
-  "types": "./dist/index.d.ts",
-  "files": ["dist"],
-  "dependencies": {
-    "better-sqlite3": "^11.8.0",
-    "node-fetch": "^3.3.2"
-  },
-  "devDependencies": {
-    "@types/better-sqlite3": "^7.6.11"
-  }
-}
+{
+  "name": "@akashabot/openclaw-memory-offline-core",
+  "version": "0.3.0",
+  "type": "module",
+  "description": "Core library for OpenClaw Offline Memory (SQLite FTS + optional embeddings)",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": ["dist"],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/AkashaBot/openclaw-memory-offline-sqlite.git",
+    "directory": "packages/core"
+  },
+  "author": "AkashaBot",
+  "license": "MIT",
+  "dependencies": {
+    "better-sqlite3": "^11.8.0",
+    "node-fetch": "^3.3.2"
+  },
+  "devDependencies": {
+    "@types/better-sqlite3": "^7.6.11"
+  }
+}