memshell 0.1.2 → 0.2.1

package/bin/memshell.js

@@ -0,0 +1,102 @@
+#!/usr/bin/env node
+'use strict';
+
+const mem = require('../src/index');
+
+const args = process.argv.slice(2);
+const cmd = args[0];
+const rest = args.slice(1).join(' ');
+
+const HELP = `
+  mem.sh — persistent memory for AI agents
+
+  Usage:
+    mem set <text>          Store a memory
+    mem recall <query>      Semantic recall
+    mem list                List all memories
+    mem forget <id>         Delete a memory by ID
+    mem clear               Wipe all memories
+    mem serve [--port N]    Start API server
+
+  Options:
+    --agent <name>          Agent namespace
+    --api <url>             Use remote API instead of local
+    --key <key>             API key for remote server
+
+  Examples:
+    mem set "user prefers dark mode"
+    mem recall "what theme?"
+    mem list
+    mem forget 3
+`;
+
+// Parse flags
+function flag(name) {
+  const i = args.indexOf('--' + name);
+  if (i === -1) return null;
+  return args[i + 1] || true;
+}
+
+async function main() {
+  const agent = flag('agent') || 'default';
+  const api = flag('api');
+  const key = flag('key');
+
+  if (api) mem.configure({ api, key, agent });
+  else mem.configure({ agent });
+
+  const opts = { agent };
+
+  switch (cmd) {
+    case 'set': case 's': case 'save': case 'remember': {
+      const text = args.slice(1).filter(a => !a.startsWith('--')).join(' ').replace(/^["']|["']$/g, '');
+      if (!text) return console.log('Usage: mem set <text>');
+      const r = await mem.set(text, opts);
+      console.log(`✓ Stored (id: ${r.id})`);
+      break;
+    }
+    case 'recall': case 'r': case 'search': case 'q': {
+      const query = args.slice(1).filter(a => !a.startsWith('--')).join(' ').replace(/^["']|["']$/g, '');
+      if (!query) return console.log('Usage: mem recall <query>');
+      const results = await mem.recall(query, opts);
+      if (!results.length) return console.log('No memories found.');
+      for (const r of results) {
+        console.log(`  [${r.id}] ${r.text} (score: ${r.score})`);
+      }
+      break;
+    }
+    case 'list': case 'ls': case 'l': {
+      const all = await mem.list(opts);
+      if (!all.length) return console.log('No memories stored.');
+      for (const r of all) {
+        console.log(`  [${r.id}] ${r.text}  (${r.created_at})`);
+      }
+      console.log(`\n  ${all.length} memor${all.length === 1 ? 'y' : 'ies'}`);
+      break;
+    }
+    case 'forget': case 'delete': case 'rm': {
+      const id = args[1];
+      if (!id) return console.log('Usage: mem forget <id>');
+      await mem.forget(id);
+      console.log(`✓ Forgotten (id: ${id})`);
+      break;
+    }
+    case 'clear': case 'wipe': case 'reset': {
+      await mem.clear(opts);
+      console.log('✓ All memories cleared');
+      break;
+    }
+    case 'serve': case 'server': {
+      const port = flag('port') || 3456;
+      const authKey = flag('key') || process.env.MEM_KEY || '';
+      process.env.MEM_PORT = port;
+      if (authKey) process.env.MEM_KEY = authKey;
+      require('../server');
+      break;
+    }
+    default:
+      console.log(HELP);
+  }
+}
+
+main().catch(e => { console.error('Error:', e.message); process.exit(1); });

package/package.json

@@ -1,11 +1,10 @@
 {
   "name": "memshell",
-  "version": "0.1.2",
+  "version": "0.2.1",
   "description": "Persistent memory for AI agents. Like localStorage but for LLMs.",
   "main": "src/index.js",
   "bin": {
-    "mem": "./bin/mem.js",
-    "mem.sh": "./bin/mem.js"
+    "memshell": "bin/memshell.js"
   },
   "scripts": {
     "start": "node server.js",
@@ -17,7 +16,7 @@
     "memory",
     "llm",
     "semantic-search",
-    "embeddings",
+    "tfidf",
     "chatgpt",
     "langchain",
     "vector",
@@ -26,7 +25,6 @@
   "author": "justedv",
   "license": "MIT",
   "dependencies": {
-    "better-sqlite3": "^11.0.0",
     "express": "^4.18.2"
   },
   "repository": {
@@ -34,4 +32,4 @@
     "url": "https://github.com/justedv/mem.sh"
   },
   "homepage": "https://justedv.github.io/mem.sh"
-}
+}

package/src/index.js

@@ -64,60 +64,75 @@ class TfIdf {
   }
 }
 
-// ── Local Store ────────────────────────────────────────────────
+// ── JSON File Store ────────────────────────────────────────────
 class LocalStore {
   constructor(dir) {
     this.dir = dir || path.join(os.homedir(), '.mem');
-    this.dbPath = path.join(this.dir, 'mem.db');
+    this.dbPath = path.join(this.dir, 'mem.json');
     this.tfidf = new TfIdf();
-    this._db = null;
-  }
-
-  get db() {
-    if (!this._db) {
-      fs.mkdirSync(this.dir, { recursive: true });
-      const Database = require('better-sqlite3');
-      this._db = new Database(this.dbPath);
-      this._db.pragma('journal_mode = WAL');
-      this._db.exec(`
-        CREATE TABLE IF NOT EXISTS memories (
-          id INTEGER PRIMARY KEY AUTOINCREMENT,
-          text TEXT NOT NULL,
-          agent TEXT DEFAULT 'default',
-          created_at TEXT DEFAULT (datetime('now')),
-          metadata TEXT DEFAULT '{}'
-        )
-      `);
+    this._data = null;
+  }
+
+  _load() {
+    if (this._data) return this._data;
+    fs.mkdirSync(this.dir, { recursive: true });
+    try {
+      this._data = JSON.parse(fs.readFileSync(this.dbPath, 'utf8'));
+    } catch {
+      this._data = { nextId: 1, memories: [] };
     }
-    return this._db;
+    return this._data;
+  }
+
+  _save() {
+    fs.writeFileSync(this.dbPath, JSON.stringify(this._data, null, 2));
   }
 
   set(text, opts = {}) {
+    const data = this._load();
     const agent = opts.agent || 'default';
-    const meta = JSON.stringify(opts.metadata || {});
-    const info = this.db.prepare('INSERT INTO memories (text, agent, metadata) VALUES (?, ?, ?)').run(text, agent, meta);
-    return { id: info.lastInsertRowid, text, agent };
+    const entry = {
+      id: data.nextId++,
+      text,
+      agent,
+      created_at: new Date().toISOString(),
+      metadata: opts.metadata || {}
+    };
+    data.memories.push(entry);
+    this._save();
+    return { id: entry.id, text, agent };
   }
 
   recall(query, opts = {}) {
+    const data = this._load();
     const agent = opts.agent || 'default';
     const limit = opts.limit || 10;
-    const rows = this.db.prepare('SELECT * FROM memories WHERE agent = ?').all(agent);
+    const rows = data.memories.filter(m => m.agent === agent);
     return this.tfidf.rank(query, rows).slice(0, limit);
   }
 
   list(opts = {}) {
+    const data = this._load();
     const agent = opts.agent || 'default';
-    return this.db.prepare('SELECT * FROM memories WHERE agent = ? ORDER BY created_at DESC').all(agent);
+    return data.memories.filter(m => m.agent === agent).sort((a, b) => b.id - a.id);
   }
 
   forget(id) {
-    return this.db.prepare('DELETE FROM memories WHERE id = ?').run(id);
+    const data = this._load();
+    const numId = Number(id);
+    const before = data.memories.length;
+    data.memories = data.memories.filter(m => m.id !== numId);
+    this._save();
+    return { changes: before - data.memories.length };
   }
 
   clear(opts = {}) {
+    const data = this._load();
     const agent = opts.agent || 'default';
-    return this.db.prepare('DELETE FROM memories WHERE agent = ?').run(agent);
+    const before = data.memories.length;
+    data.memories = data.memories.filter(m => m.agent !== agent);
+    this._save();
+    return { changes: before - data.memories.length };
   }
 }
 
@@ -129,9 +144,9 @@ class ApiClient {
     this.agent = opts.agent || 'default';
   }
 
-  _req(method, path, body) {
+  _req(method, urlPath, body) {
     return new Promise((resolve, reject) => {
-      const url = new URL(this.base + path);
+      const url = new URL(this.base + urlPath);
       const mod = url.protocol === 'https:' ? https : http;
       const headers = { 'Content-Type': 'application/json' };
       if (this.key) headers['X-Mem-Key'] = this.key;
@@ -153,7 +168,7 @@ class ApiClient {
   recall(query, opts = {}) { return this._req('GET', `/mem/recall?q=${encodeURIComponent(query)}&limit=${opts.limit || 10}`); }
   list() { return this._req('GET', '/mem/list'); }
   forget(id) { return this._req('DELETE', `/mem/${id}`); }
-  clear() { return this._req('DELETE', '/mem'); }
+  clear() { return this._req('DELETE', '/mem?confirm=true'); }
 }
 
 // ── Exports ────────────────────────────────────────────────────