@akashabot/openclaw-mem 0.2.0 → 0.4.0

package/dist/cli.js

@@ -3,7 +3,11 @@ import { Command } from 'commander';
 import fs from 'node:fs';
 import { v4 as uuidv4 } from 'uuid';
 import * as core from '@akashabot/openclaw-memory-offline-core';
-const { addItem, hybridSearch, hybridSearchFiltered, initSchema, openDb, runMigrations, searchItems, getMemoriesByEntity, getMemoriesBySession, getMemoriesByProcess, listEntities, listSessions, } = core;
+const { addItem, hybridSearch, hybridSearchFiltered, initSchema, openDb, runMigrations, searchItems, getMemoriesByEntity, getMemoriesBySession, getMemoriesByProcess, listEntities, listSessions, 
+// Phase 2: Facts
+insertFact, getFactsBySubject, getFactsByPredicate, searchFacts, getAllFacts, listSubjects, listPredicates, deleteFact, extractFactsSimple, 
+// Phase 3: Knowledge Graph
+getEntityGraph, getRelatedEntities, findPaths, getGraphStats, exportGraphJson, searchEntities, } = core;
 const program = new Command();
 program
     .name('openclaw-mem')
@@ -204,4 +208,201 @@ program
         console.log(JSON.stringify({ ok: true, sessionId, count: items.length, items }));
     });
 });
+// ============================================================================
+// Phase 2: Fact commands
+// ============================================================================
+program
+    .command('add-fact <subject> <predicate> <object>')
+    .description('Add a structured fact (subject, predicate, object)')
+    .option('--confidence <n>', 'Confidence level 0-1 (default 0.7)', '0.7')
+    .option('--entity-id <entityId>', 'Who said/wrote this fact')
+    .option('--source-item-id <itemId>', 'Source memory item ID')
+    .action((subject, predicate, object, cmdOpts) => {
+    withDb((dbPath) => {
+        const db = openDb(dbPath);
+        initSchema(db);
+        const id = uuidv4();
+        const confidence = Math.max(0, Math.min(1, Number(cmdOpts.confidence ?? 0.7)));
+        const fact = insertFact(db, {
+            id,
+            subject,
+            predicate,
+            object,
+            confidence,
+            source_item_id: cmdOpts.sourceItemId ?? null,
+            entity_id: cmdOpts.entityId ?? null,
+        });
+        console.log(JSON.stringify({ ok: true, fact }));
+    });
+});
+program
+    .command('list-facts')
+    .description('List all facts (optionally filtered by entity)')
+    .option('--entity-id <entityId>', 'Filter by entity')
+    .option('--limit <n>', 'Max results (default 50)', '50')
+    .action((cmdOpts) => {
+    withDb((dbPath) => {
+        const db = openDb(dbPath);
+        initSchema(db);
+        const limit = Math.max(1, Math.min(500, Number(cmdOpts.limit ?? 50)));
+        const facts = getAllFacts(db, cmdOpts.entityId, limit);
+        console.log(JSON.stringify({ ok: true, count: facts.length, facts }));
+    });
+});
+program
+    .command('get-facts-by-subject <subject>')
+    .description('Get all facts about a specific subject')
+    .option('--limit <n>', 'Max results (default 50)', '50')
+    .action((subject, cmdOpts) => {
+    withDb((dbPath) => {
+        const db = openDb(dbPath);
+        initSchema(db);
+        const limit = Math.max(1, Math.min(500, Number(cmdOpts.limit ?? 50)));
+        const facts = getFactsBySubject(db, subject, limit);
+        console.log(JSON.stringify({ ok: true, subject, count: facts.length, facts }));
+    });
+});
+program
+    .command('search-facts <query>')
+    .description('Search facts by subject, predicate, or object')
+    .option('--limit <n>', 'Max results (default 50)', '50')
+    .action((query, cmdOpts) => {
+    withDb((dbPath) => {
+        const db = openDb(dbPath);
+        initSchema(db);
+        const limit = Math.max(1, Math.min(500, Number(cmdOpts.limit ?? 50)));
+        const facts = searchFacts(db, query, limit);
+        console.log(JSON.stringify({ ok: true, query, count: facts.length, facts }));
+    });
+});
+program
+    .command('list-subjects')
+    .description('List all distinct subjects in the facts table')
+    .action(() => {
+    withDb((dbPath) => {
+        const db = openDb(dbPath);
+        initSchema(db);
+        const subjects = listSubjects(db);
+        console.log(JSON.stringify({ ok: true, subjects, count: subjects.length }));
+    });
+});
+program
+    .command('list-predicates')
+    .description('List all distinct predicates in the facts table')
+    .action(() => {
+    withDb((dbPath) => {
+        const db = openDb(dbPath);
+        initSchema(db);
+        const predicates = listPredicates(db);
+        console.log(JSON.stringify({ ok: true, predicates, count: predicates.length }));
+    });
+});
+program
+    .command('delete-fact <factId>')
+    .description('Delete a fact by ID')
+    .action((factId) => {
+    withDb((dbPath) => {
+        const db = openDb(dbPath);
+        initSchema(db);
+        const deleted = deleteFact(db, factId);
+        console.log(JSON.stringify({ ok: true, deleted, id: factId }));
+    });
+});
+program
+    .command('extract-facts [text]')
+    .description('Extract potential facts from text (pattern-based, does not store)')
+    .action((text) => {
+    const input = text ?? fs.readFileSync(0, 'utf-8');
+    const facts = extractFactsSimple(input);
+    console.log(JSON.stringify({ ok: true, count: facts.length, facts }));
+});
+// ============================================================================
+// Phase 3: Knowledge Graph commands
+// ============================================================================
+program
+    .command('graph-stats')
+    .description('Get statistics about the knowledge graph')
+    .action(() => {
+    withDb((dbPath) => {
+        const db = openDb(dbPath);
+        initSchema(db);
+        const stats = getGraphStats(db);
+        console.log(JSON.stringify({ ok: true, stats }, null, 2));
+    });
+});
+program
+    .command('graph-entity <entity>')
+    .description('Get all facts connected to an entity (as subject or object)')
+    .action((entity) => {
+    withDb((dbPath) => {
+        const db = openDb(dbPath);
+        initSchema(db);
+        const edges = getEntityGraph(db, entity);
+        console.log(JSON.stringify({ ok: true, entity, count: edges.length, edges }));
+    });
+});
+program
+    .command('graph-related <entity>')
+    .description('Get all entities directly connected to an entity')
+    .action((entity) => {
+    withDb((dbPath) => {
+        const db = openDb(dbPath);
+        initSchema(db);
+        const related = getRelatedEntities(db, entity);
+        console.log(JSON.stringify({ ok: true, entity, count: related.length, related }));
+    });
+});
+program
+    .command('graph-path <fromEntity> <toEntity>')
+    .description('Find paths between two entities in the knowledge graph')
+    .option('--max-depth <n>', 'Maximum path depth (default 4)', '4')
+    .option('--max-paths <n>', 'Maximum number of paths to return (default 5)', '5')
+    .action((fromEntity, toEntity, cmdOpts) => {
+    withDb((dbPath) => {
+        const db = openDb(dbPath);
+        initSchema(db);
+        const maxDepth = Math.max(1, Math.min(10, Number(cmdOpts.maxDepth ?? 4)));
+        const maxPaths = Math.max(1, Math.min(20, Number(cmdOpts.maxPaths ?? 5)));
+        const paths = findPaths(db, fromEntity, toEntity, maxDepth, maxPaths);
+        console.log(JSON.stringify({ ok: true, from: fromEntity, to: toEntity, count: paths.length, paths }));
+    });
+});
+program
+    .command('graph-export [outputFile]')
+    .description('Export the knowledge graph as JSON (for visualization)')
+    .option('--limit <n>', 'Max edges to export (default 1000)', '1000')
+    .option('--min-confidence <n>', 'Minimum confidence threshold (default 0)', '0')
+    .option('--entity <entity>', 'Export only subgraph around this entity')
+    .action((outputFile, cmdOpts) => {
+    withDb((dbPath) => {
+        const db = openDb(dbPath);
+        initSchema(db);
+        const graph = exportGraphJson(db, {
+            limit: Number(cmdOpts.limit ?? 1000),
+            minConfidence: Number(cmdOpts.minConfidence ?? 0),
+            entity: cmdOpts.entity,
+        });
+        const output = JSON.stringify({ ok: true, graph }, null, 2);
+        if (outputFile) {
+            fs.writeFileSync(outputFile, output);
+            console.log(JSON.stringify({ ok: true, file: outputFile, nodes: graph.nodes.length, edges: graph.edges.length }));
+        }
+        else {
+            console.log(output);
+        }
+    });
+});
+program
+    .command('search-entities <pattern>')
+    .description('Search for entities matching a pattern')
+    .option('--limit <n>', 'Max results (default 50)', '50')
+    .action((pattern, cmdOpts) => {
+    withDb((dbPath) => {
+        const db = openDb(dbPath);
+        initSchema(db);
+        const limit = Math.max(1, Math.min(500, Number(cmdOpts.limit ?? 50)));
+        const entities = searchEntities(db, pattern, limit);
+        console.log(JSON.stringify({ ok: true, pattern, count: entities.length, entities }));
+    });
+});
 program.parse();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@akashabot/openclaw-mem",
-  "version": "0.2.0",
+  "version": "0.4.0",
   "type": "module",
   "description": "CLI for OpenClaw Offline Memory (SQLite FTS + optional embeddings)",
   "bin": {
@@ -17,7 +17,7 @@
   "dependencies": {
     "commander": "^12.1.0",
     "uuid": "^10.0.0",
-    "@akashabot/openclaw-memory-offline-core": "^0.2.0"
+    "@akashabot/openclaw-memory-offline-core": "^0.4.0"
   },
   "devDependencies": {
     "@types/uuid": "^10.0.0"

package/src/cli.ts

@@ -17,6 +17,23 @@ const {
   getMemoriesByProcess,
   listEntities,
   listSessions,
+  // Phase 2: Facts
+  insertFact,
+  getFactsBySubject,
+  getFactsByPredicate,
+  searchFacts,
+  getAllFacts,
+  listSubjects,
+  listPredicates,
+  deleteFact,
+  extractFactsSimple,
+  // Phase 3: Knowledge Graph
+  getEntityGraph,
+  getRelatedEntities,
+  findPaths,
+  getGraphStats,
+  exportGraphJson,
+  searchEntities,
 } = core;
 
 const program = new Command();
@@ -254,4 +271,217 @@ program
     });
   });
 
+// ============================================================================
+// Phase 2: Fact commands
+// ============================================================================
+
+program
+  .command('add-fact <subject> <predicate> <object>')
+  .description('Add a structured fact (subject, predicate, object)')
+  .option('--confidence <n>', 'Confidence level 0-1 (default 0.7)', '0.7')
+  .option('--entity-id <entityId>', 'Who said/wrote this fact')
+  .option('--source-item-id <itemId>', 'Source memory item ID')
+  .action((subject: string, predicate: string, object: string, cmdOpts) => {
+    withDb((dbPath) => {
+      const db = openDb(dbPath);
+      initSchema(db);
+      const id = uuidv4();
+      const confidence = Math.max(0, Math.min(1, Number(cmdOpts.confidence ?? 0.7)));
+      const fact = insertFact(db, {
+        id,
+        subject,
+        predicate,
+        object,
+        confidence,
+        source_item_id: cmdOpts.sourceItemId ?? null,
+        entity_id: cmdOpts.entityId ?? null,
+      });
+      console.log(JSON.stringify({ ok: true, fact }));
+    });
+  });
+
+program
+  .command('list-facts')
+  .description('List all facts (optionally filtered by entity)')
+  .option('--entity-id <entityId>', 'Filter by entity')
+  .option('--limit <n>', 'Max results (default 50)', '50')
+  .action((cmdOpts) => {
+    withDb((dbPath) => {
+      const db = openDb(dbPath);
+      initSchema(db);
+      const limit = Math.max(1, Math.min(500, Number(cmdOpts.limit ?? 50)));
+      const facts = getAllFacts(db, cmdOpts.entityId, limit);
+      console.log(JSON.stringify({ ok: true, count: facts.length, facts }));
+    });
+  });
+
+program
+  .command('get-facts-by-subject <subject>')
+  .description('Get all facts about a specific subject')
+  .option('--limit <n>', 'Max results (default 50)', '50')
+  .action((subject: string, cmdOpts) => {
+    withDb((dbPath) => {
+      const db = openDb(dbPath);
+      initSchema(db);
+      const limit = Math.max(1, Math.min(500, Number(cmdOpts.limit ?? 50)));
+      const facts = getFactsBySubject(db, subject, limit);
+      console.log(JSON.stringify({ ok: true, subject, count: facts.length, facts }));
+    });
+  });
+
+program
+  .command('search-facts <query>')
+  .description('Search facts by subject, predicate, or object')
+  .option('--limit <n>', 'Max results (default 50)', '50')
+  .action((query: string, cmdOpts) => {
+    withDb((dbPath) => {
+      const db = openDb(dbPath);
+      initSchema(db);
+      const limit = Math.max(1, Math.min(500, Number(cmdOpts.limit ?? 50)));
+      const facts = searchFacts(db, query, limit);
+      console.log(JSON.stringify({ ok: true, query, count: facts.length, facts }));
+    });
+  });
+
+program
+  .command('list-subjects')
+  .description('List all distinct subjects in the facts table')
+  .action(() => {
+    withDb((dbPath) => {
+      const db = openDb(dbPath);
+      initSchema(db);
+      const subjects = listSubjects(db);
+      console.log(JSON.stringify({ ok: true, subjects, count: subjects.length }));
+    });
+  });
+
+program
+  .command('list-predicates')
+  .description('List all distinct predicates in the facts table')
+  .action(() => {
+    withDb((dbPath) => {
+      const db = openDb(dbPath);
+      initSchema(db);
+      const predicates = listPredicates(db);
+      console.log(JSON.stringify({ ok: true, predicates, count: predicates.length }));
+    });
+  });
+
+program
+  .command('delete-fact <factId>')
+  .description('Delete a fact by ID')
+  .action((factId: string) => {
+    withDb((dbPath) => {
+      const db = openDb(dbPath);
+      initSchema(db);
+      const deleted = deleteFact(db, factId);
+      console.log(JSON.stringify({ ok: true, deleted, id: factId }));
+    });
+  });
+
+program
+  .command('extract-facts [text]')
+  .description('Extract potential facts from text (pattern-based, does not store)')
+  .action((text: string | undefined) => {
+    const input = text ?? fs.readFileSync(0, 'utf-8');
+    const facts = extractFactsSimple(input);
+    console.log(JSON.stringify({ ok: true, count: facts.length, facts }));
+  });
+
+// ============================================================================
+// Phase 3: Knowledge Graph commands
+// ============================================================================
+
+program
+  .command('graph-stats')
+  .description('Get statistics about the knowledge graph')
+  .action(() => {
+    withDb((dbPath) => {
+      const db = openDb(dbPath);
+      initSchema(db);
+      const stats = getGraphStats(db);
+      console.log(JSON.stringify({ ok: true, stats }, null, 2));
+    });
+  });
+
+program
+  .command('graph-entity <entity>')
+  .description('Get all facts connected to an entity (as subject or object)')
+  .action((entity: string) => {
+    withDb((dbPath) => {
+      const db = openDb(dbPath);
+      initSchema(db);
+      const edges = getEntityGraph(db, entity);
+      console.log(JSON.stringify({ ok: true, entity, count: edges.length, edges }));
+    });
+  });
+
+program
+  .command('graph-related <entity>')
+  .description('Get all entities directly connected to an entity')
+  .action((entity: string) => {
+    withDb((dbPath) => {
+      const db = openDb(dbPath);
+      initSchema(db);
+      const related = getRelatedEntities(db, entity);
+      console.log(JSON.stringify({ ok: true, entity, count: related.length, related }));
+    });
+  });
+
+program
+  .command('graph-path <fromEntity> <toEntity>')
+  .description('Find paths between two entities in the knowledge graph')
+  .option('--max-depth <n>', 'Maximum path depth (default 4)', '4')
+  .option('--max-paths <n>', 'Maximum number of paths to return (default 5)', '5')
+  .action((fromEntity: string, toEntity: string, cmdOpts) => {
+    withDb((dbPath) => {
+      const db = openDb(dbPath);
+      initSchema(db);
+      const maxDepth = Math.max(1, Math.min(10, Number(cmdOpts.maxDepth ?? 4)));
+      const maxPaths = Math.max(1, Math.min(20, Number(cmdOpts.maxPaths ?? 5)));
+      const paths = findPaths(db, fromEntity, toEntity, maxDepth, maxPaths);
+      console.log(JSON.stringify({ ok: true, from: fromEntity, to: toEntity, count: paths.length, paths }));
+    });
+  });
+
+program
+  .command('graph-export [outputFile]')
+  .description('Export the knowledge graph as JSON (for visualization)')
+  .option('--limit <n>', 'Max edges to export (default 1000)', '1000')
+  .option('--min-confidence <n>', 'Minimum confidence threshold (default 0)', '0')
+  .option('--entity <entity>', 'Export only subgraph around this entity')
+  .action((outputFile: string | undefined, cmdOpts) => {
+    withDb((dbPath) => {
+      const db = openDb(dbPath);
+      initSchema(db);
+      const graph = exportGraphJson(db, {
+        limit: Number(cmdOpts.limit ?? 1000),
+        minConfidence: Number(cmdOpts.minConfidence ?? 0),
+        entity: cmdOpts.entity,
+      });
+
+      const output = JSON.stringify({ ok: true, graph }, null, 2);
+      if (outputFile) {
+        fs.writeFileSync(outputFile, output);
+        console.log(JSON.stringify({ ok: true, file: outputFile, nodes: graph.nodes.length, edges: graph.edges.length }));
+      } else {
+        console.log(output);
+      }
+    });
+  });
+
+program
+  .command('search-entities <pattern>')
+  .description('Search for entities matching a pattern')
+  .option('--limit <n>', 'Max results (default 50)', '50')
+  .action((pattern: string, cmdOpts) => {
+    withDb((dbPath) => {
+      const db = openDb(dbPath);
+      initSchema(db);
+      const limit = Math.max(1, Math.min(500, Number(cmdOpts.limit ?? 50)));
+      const entities = searchEntities(db, pattern, limit);
+      console.log(JSON.stringify({ ok: true, pattern, count: entities.length, entities }));
+    });
+  });
+
 program.parse();