mcp-simple-memory 0.2.0 → 0.3.0

package/README.md

@@ -149,6 +149,56 @@ mem_search({ query: "authentication problem", tag: "bug" })
 3. **Auto mode**: Keyword first. If < 3 results, falls back to vector search.
 4. **Tags**: Lightweight categorization. Normalized to lowercase.
 
+## Import Existing Knowledge
+
+Already have notes, docs, or session logs? Import them directly:
+
+```bash
+# Import a single file
+npx mcp-simple-memory import CLAUDE.md --project my-app --tags setup
+
+# Import all .md files in a directory
+npx mcp-simple-memory import ./docs --tags documentation
+
+# Preview what would be imported (no changes)
+npx mcp-simple-memory import ./notes --dry-run
+
+# With semantic search (auto-generates embeddings during import)
+GEMINI_API_KEY=your-key npx mcp-simple-memory import memory.md
+```
+
+The importer splits markdown files by headings (`#`, `##`, `###`) into individual memories. Each section becomes a searchable memory entry.
+
+### Options
+
+| Flag | Description |
+|------|-------------|
+| `--project <name>` | Set project name (default: filename) |
+| `--tags <t1,t2>` | Add tags to all imported memories |
+| `--dry-run` | Preview without saving |
+
+## Database Stats
+
+Check what's in your memory:
+
+```bash
+npx mcp-simple-memory stats
+```
+
+Output:
+```
+mcp-simple-memory stats
+  DB: ~/.mcp-simple-memory/memory.db
+
+  Memories:   42
+  Embeddings: 42/42 (100%)
+  Tags:       15 unique
+
+  Projects:
+    my-app: 30
+    default: 12
+```
+
 ## Data Storage
 
 All data stays local:

package/dist/cli.d.ts

@@ -3,7 +3,10 @@
  * CLI for mcp-simple-memory
  *
  * Usage:
- *   npx mcp-simple-memory init   — Add to .mcp.json
- *   npx mcp-simple-memory serve  — Start MCP server (used by Claude Code)
+ *   npx mcp-simple-memory init              — Add to .mcp.json
+ *   npx mcp-simple-memory serve             — Start MCP server (used by Claude Code)
+ *   npx mcp-simple-memory import <file>     — Import .md file as memories
+ *   npx mcp-simple-memory import <dir>      — Import all .md files in directory
+ *   npx mcp-simple-memory stats             — Show memory database stats
  */
 export {};

package/dist/cli.js

@@ -3,28 +3,50 @@
  * CLI for mcp-simple-memory
  *
  * Usage:
- *   npx mcp-simple-memory init   — Add to .mcp.json
- *   npx mcp-simple-memory serve  — Start MCP server (used by Claude Code)
+ *   npx mcp-simple-memory init              — Add to .mcp.json
+ *   npx mcp-simple-memory serve             — Start MCP server (used by Claude Code)
+ *   npx mcp-simple-memory import <file>     — Import .md file as memories
+ *   npx mcp-simple-memory import <dir>      — Import all .md files in directory
+ *   npx mcp-simple-memory stats             — Show memory database stats
  */
-import { readFileSync, writeFileSync, existsSync } from "fs";
-import { join } from "path";
+import { readFileSync, writeFileSync, existsSync, readdirSync, statSync, mkdirSync } from "fs";
+import { join, basename, extname, resolve } from "path";
+import { homedir } from "os";
+import initSqlJs from "sql.js";
+// Config - must be before command dispatch
+const DATA_DIR = process.env.MCP_MEMORY_DIR || join(homedir(), ".mcp-simple-memory");
+const DB_PATH = join(DATA_DIR, "memory.db");
+const GEMINI_API_KEY = process.env.GEMINI_API_KEY || "";
+const GEMINI_MODEL = "gemini-embedding-001";
 const args = process.argv.slice(2);
 const command = args[0] || "serve";
 if (command === "init") {
     init();
 }
 else if (command === "serve") {
-    // Import and run the server
     await import("./index.js");
 }
+else if (command === "import") {
+    await importMemories(args[1], args.slice(2));
+}
+else if (command === "stats") {
+    await showStats();
+}
 else if (command === "help" || command === "--help" || command === "-h") {
     console.log(`
 mcp-simple-memory — Persistent memory for Claude Code
 
 Commands:
-  init    Add mcp-simple-memory to .mcp.json in current directory
-  serve   Start the MCP server (default, used by Claude Code)
-  help    Show this help
+  init                    Add mcp-simple-memory to .mcp.json in current directory
+  serve                   Start the MCP server (default, used by Claude Code)
+  import <file|dir>       Import .md files as memories
+  stats                   Show database statistics
+  help                    Show this help
+
+Import options:
+  --project <name>        Set project name (default: filename without extension)
+  --tags <t1,t2>          Add tags to all imported memories
+  --dry-run               Show what would be imported without saving
 
 Environment variables:
   GEMINI_API_KEY     Enable semantic search (optional, free tier works)
@@ -35,6 +57,100 @@ else {
     console.error(`Unknown command: ${command}. Run 'mcp-simple-memory help' for usage.`);
     process.exit(1);
 }
+// ---- Database helpers (shared with index.ts) --------------------------------
+async function openDb() {
+    if (!existsSync(DATA_DIR))
+        mkdirSync(DATA_DIR, { recursive: true });
+    const SQL = await initSqlJs();
+    let db;
+    if (existsSync(DB_PATH)) {
+        db = new SQL.Database(readFileSync(DB_PATH));
+    }
+    else {
+        db = new SQL.Database();
+    }
+    db.run(`CREATE TABLE IF NOT EXISTS memories (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    title TEXT, content TEXT NOT NULL,
+    type TEXT DEFAULT 'memory', project TEXT DEFAULT 'default',
+    created_at INTEGER NOT NULL, created_iso TEXT NOT NULL,
+    updated_at INTEGER, updated_iso TEXT
+  )`);
+    db.run(`CREATE TABLE IF NOT EXISTS embeddings (
+    memory_id INTEGER PRIMARY KEY, vector BLOB NOT NULL
+  )`);
+    db.run(`CREATE TABLE IF NOT EXISTS tags (
+    memory_id INTEGER NOT NULL, tag TEXT NOT NULL,
+    PRIMARY KEY (memory_id, tag)
+  )`);
+    return db;
+}
+function persistDb(db) {
+    writeFileSync(DB_PATH, Buffer.from(db.export()));
+}
+function queryAll(db, sql, params = []) {
+    const stmt = db.prepare(sql);
+    if (params.length)
+        stmt.bind(params);
+    const rows = [];
+    while (stmt.step())
+        rows.push(stmt.getAsObject());
+    stmt.free();
+    return rows;
+}
+async function getEmbedding(text) {
+    if (!GEMINI_API_KEY)
+        return null;
+    try {
+        const res = await fetch(`https://generativelanguage.googleapis.com/v1beta/models/${GEMINI_MODEL}:embedContent?key=${GEMINI_API_KEY}`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({
+                model: `models/${GEMINI_MODEL}`,
+                content: { parts: [{ text }] },
+            }),
+        });
+        if (!res.ok)
+            return null;
+        const data = (await res.json());
+        return new Float32Array(data.embedding.values);
+    }
+    catch {
+        return null;
+    }
+}
+function chunkMarkdown(text) {
+    const lines = text.split("\n");
+    const chunks = [];
+    let currentTitle = "";
+    let currentContent = [];
+    let currentLevel = 0;
+    for (const line of lines) {
+        const headingMatch = line.match(/^(#{1,3})\s+(.+)/);
+        if (headingMatch) {
+            // Save previous chunk
+            if (currentContent.length > 0 || currentTitle) {
+                const content = currentContent.join("\n").trim();
+                if (content.length > 10) {
+                    chunks.push({ title: currentTitle, content, level: currentLevel });
+                }
+            }
+            currentTitle = headingMatch[2].trim();
+            currentLevel = headingMatch[1].length;
+            currentContent = [];
+        }
+        else {
+            currentContent.push(line);
+        }
+    }
+    // Last chunk
+    const content = currentContent.join("\n").trim();
+    if (content.length > 10) {
+        chunks.push({ title: currentTitle, content, level: currentLevel });
+    }
+    return chunks;
+}
+// ---- Commands ---------------------------------------------------------------
 function init() {
     const mcpPath = join(process.cwd(), ".mcp.json");
     let config = {};
@@ -68,3 +184,140 @@ function init() {
     console.log("Example with semantic search:");
     console.log('  "env": { "GEMINI_API_KEY": "your-key-here" }');
 }
+async function importMemories(target, flags) {
+    if (!target) {
+        console.error("Usage: mcp-simple-memory import <file.md|directory> [--project name] [--tags t1,t2] [--dry-run]");
+        process.exit(1);
+    }
+    // Parse flags
+    let project;
+    let extraTags = [];
+    let dryRun = false;
+    for (let i = 0; i < flags.length; i++) {
+        if (flags[i] === "--project" && flags[i + 1]) {
+            project = flags[++i];
+        }
+        else if (flags[i] === "--tags" && flags[i + 1]) {
+            extraTags = flags[++i].split(",").map((t) => t.trim().toLowerCase()).filter(Boolean);
+        }
+        else if (flags[i] === "--dry-run") {
+            dryRun = true;
+        }
+    }
+    const resolvedTarget = resolve(target);
+    // Collect files
+    let files = [];
+    if (!existsSync(resolvedTarget)) {
+        console.error(`Not found: ${resolvedTarget}`);
+        process.exit(1);
+    }
+    if (statSync(resolvedTarget).isDirectory()) {
+        files = readdirSync(resolvedTarget)
+            .filter((f) => extname(f).toLowerCase() === ".md")
+            .map((f) => join(resolvedTarget, f))
+            .sort();
+    }
+    else {
+        files = [resolvedTarget];
+    }
+    if (!files.length) {
+        console.error("No .md files found.");
+        process.exit(1);
+    }
+    console.log(`Found ${files.length} file(s) to import.\n`);
+    const db = await openDb();
+    let totalChunks = 0;
+    let totalEmbedded = 0;
+    for (const file of files) {
+        const name = basename(file, ".md");
+        const proj = project || name;
+        const raw = readFileSync(file, "utf-8");
+        const chunks = chunkMarkdown(raw);
+        console.log(`${name}.md → ${chunks.length} chunks (project: ${proj})`);
+        for (const chunk of chunks) {
+            const tags = [...extraTags];
+            // Auto-tag from heading level
+            if (chunk.level === 1)
+                tags.push("section");
+            if (chunk.level === 2)
+                tags.push("subsection");
+            if (dryRun) {
+                const preview = chunk.content.substring(0, 60).replace(/\n/g, " ");
+                console.log(`  [dry-run] "${chunk.title}" (${chunk.content.length} chars) ${preview}...`);
+                totalChunks++;
+                continue;
+            }
+            const now = Date.now();
+            db.run(`INSERT INTO memories (title, content, type, project, created_at, created_iso) VALUES (?, ?, ?, ?, ?, ?)`, [chunk.title || name, chunk.content, "memory", proj, now, new Date(now).toISOString()]);
+            const id = queryAll(db, `SELECT last_insert_rowid() as id`)[0]?.id ?? 0;
+            // Tags
+            for (const tag of tags) {
+                if (tag)
+                    db.run(`INSERT OR IGNORE INTO tags (memory_id, tag) VALUES (?, ?)`, [id, tag.toLowerCase()]);
+            }
+            // Embedding
+            if (GEMINI_API_KEY) {
+                const vec = await getEmbedding(`${chunk.title}\n${chunk.content}`);
+                if (vec) {
+                    db.run(`INSERT OR REPLACE INTO embeddings (memory_id, vector) VALUES (?, ?)`, [
+                        id,
+                        new Uint8Array(vec.buffer),
+                    ]);
+                    totalEmbedded++;
+                }
+                // Rate limit
+                await new Promise((r) => setTimeout(r, 100));
+            }
+            const tagStr = tags.length ? ` [${tags.join(", ")}]` : "";
+            console.log(`  #${id} "${chunk.title}" (${chunk.content.length} chars)${tagStr}`);
+            totalChunks++;
+        }
+    }
+    if (!dryRun) {
+        persistDb(db);
+    }
+    db.close();
+    console.log(`\n${dryRun ? "[DRY RUN] " : ""}Imported ${totalChunks} memories from ${files.length} file(s).`);
+    if (totalEmbedded > 0) {
+        console.log(`Generated ${totalEmbedded} embeddings.`);
+    }
+    else if (!GEMINI_API_KEY && !dryRun) {
+        console.log("Tip: Set GEMINI_API_KEY to auto-generate embeddings during import.");
+    }
+}
+async function showStats() {
+    if (!existsSync(DB_PATH)) {
+        console.log("No database found. Run 'mcp-simple-memory init' first.");
+        return;
+    }
+    const db = await openDb();
+    const memCount = queryAll(db, `SELECT COUNT(*) as c FROM memories`)[0]?.c ?? 0;
+    const embCount = queryAll(db, `SELECT COUNT(*) as c FROM embeddings`)[0]?.c ?? 0;
+    const tagCount = queryAll(db, `SELECT COUNT(DISTINCT tag) as c FROM tags`)[0]?.c ?? 0;
+    const projects = queryAll(db, `SELECT project, COUNT(*) as c FROM memories GROUP BY project ORDER BY c DESC`);
+    const types = queryAll(db, `SELECT type, COUNT(*) as c FROM memories GROUP BY type ORDER BY c DESC`);
+    const topTags = queryAll(db, `SELECT tag, COUNT(*) as c FROM tags GROUP BY tag ORDER BY c DESC LIMIT 10`);
+    console.log(`mcp-simple-memory stats`);
+    console.log(`  DB: ${DB_PATH}\n`);
+    console.log(`  Memories:   ${memCount}`);
+    console.log(`  Embeddings: ${embCount}/${memCount} (${memCount ? Math.round(embCount / memCount * 100) : 0}%)`);
+    console.log(`  Tags:       ${tagCount} unique\n`);
+    if (projects.length) {
+        console.log(`  Projects:`);
+        for (const p of projects)
+            console.log(`    ${p.project}: ${p.c}`);
+        console.log("");
+    }
+    if (types.length) {
+        console.log(`  Types:`);
+        for (const t of types)
+            console.log(`    ${t.type}: ${t.c}`);
+        console.log("");
+    }
+    if (topTags.length) {
+        console.log(`  Top tags:`);
+        for (const t of topTags)
+            console.log(`    ${t.tag}: ${t.c}`);
+    }
+    db.close();
+}

package/dist/index.js

@@ -217,7 +217,7 @@ async function handleSave(args) {
     if (GEMINI_API_KEY) {
         getEmbedding(`${title}\n${content}`).then((vec) => {
             if (vec) {
-                runSql(`INSERT OR REPLACE INTO embeddings (memory_id, vector) VALUES (?, ?)`, [id, vec.buffer]);
+                runSql(`INSERT OR REPLACE INTO embeddings (memory_id, vector) VALUES (?, ?)`, [id, new Uint8Array(vec.buffer)]);
                 persist();
             }
         });
@@ -425,7 +425,7 @@ async function handleUpdate(args) {
         const newTitle = args.title || existing[0].title;
         getEmbedding(`${newTitle}\n${newContent}`).then((vec) => {
             if (vec) {
-                runSql(`INSERT OR REPLACE INTO embeddings (memory_id, vector) VALUES (?, ?)`, [id, vec.buffer]);
+                runSql(`INSERT OR REPLACE INTO embeddings (memory_id, vector) VALUES (?, ?)`, [id, new Uint8Array(vec.buffer)]);
                 persist();
             }
         });
@@ -462,7 +462,7 @@ async function handleTags(args) {
     return ok(`# Tags (${rows.length})\n\n${lines.join("\n")}`);
 }
 // ---- MCP Server -----------------------------------------------------------
-const server = new Server({ name: "mcp-simple-memory", version: "0.2.0" }, { capabilities: { tools: {} } });
+const server = new Server({ name: "mcp-simple-memory", version: "0.3.0" }, { capabilities: { tools: {} } });
 const tools = [
     {
         name: "mem_save",
@@ -620,7 +620,7 @@ async function main() {
     await initDb();
     const transport = new StdioServerTransport();
     await server.connect(transport);
-    console.error(`[mcp-simple-memory] v0.2.0 | DB: ${DB_PATH} | Embeddings: ${GEMINI_API_KEY ? "ON" : "OFF"}`);
+    console.error(`[mcp-simple-memory] v0.3.0 | DB: ${DB_PATH} | Embeddings: ${GEMINI_API_KEY ? "ON" : "OFF"}`);
 }
 main().catch((e) => {
     console.error(`[mcp-simple-memory] Fatal: ${e}`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mcp-simple-memory",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "Persistent memory for Claude Code via MCP. SQLite + optional semantic search. Zero native deps. Works on Windows/Mac/Linux.",
   "type": "module",
   "main": "dist/index.js",