@telvok/librarian-mcp 1.3.0 → 1.5.0

package/dist/library/parsers/index.d.ts

@@ -2,3 +2,5 @@ export type { ParsedEntry, ParseResult } from './types.js';
 export { parseJSONL } from './jsonl.js';
 export { parseMarkdown } from './markdown.js';
 export { parseCursorMemory } from './cursor.js';
+export { parseJSON } from './json.js';
+export { parseSQLite } from './sqlite.js';

package/dist/library/parsers/index.js

@@ -1,3 +1,5 @@
 export { parseJSONL } from './jsonl.js';
 export { parseMarkdown } from './markdown.js';
 export { parseCursorMemory } from './cursor.js';
+export { parseJSON } from './json.js';
+export { parseSQLite } from './sqlite.js';

package/dist/library/parsers/json.d.ts

@@ -0,0 +1,11 @@
+import type { ParseResult } from './types.js';
+/**
+ * Parse a JSON file containing an array of memory entries.
+ *
+ * Supports various common structures:
+ * - Array of objects with title/content
+ * - Array of objects with name/description
+ * - Object with entries array
+ * - Object with memories array
+ */
+export declare function parseJSON(filePath: string): Promise<ParseResult>;

package/dist/library/parsers/json.js

@@ -0,0 +1,95 @@
+import * as fs from 'fs/promises';
+/**
+ * Parse a JSON file containing an array of memory entries.
+ *
+ * Supports various common structures:
+ * - Array of objects with title/content
+ * - Array of objects with name/description
+ * - Object with entries array
+ * - Object with memories array
+ */
+export async function parseJSON(filePath) {
+    const entries = [];
+    const errors = [];
+    let skipped = 0;
+    try {
+        const content = await fs.readFile(filePath, 'utf-8');
+        const data = JSON.parse(content);
+        // Handle different JSON structures
+        let items = [];
+        if (Array.isArray(data)) {
+            // Direct array of entries
+            items = data;
+        }
+        else if (typeof data === 'object' && data !== null) {
+            // Object with entries/memories/items array
+            if (Array.isArray(data.entries)) {
+                items = data.entries;
+            }
+            else if (Array.isArray(data.memories)) {
+                items = data.memories;
+            }
+            else if (Array.isArray(data.items)) {
+                items = data.items;
+            }
+            else if (Array.isArray(data.data)) {
+                items = data.data;
+            }
+            else {
+                // Single object - treat as one entry
+                items = [data];
+            }
+        }
+        for (let i = 0; i < items.length; i++) {
+            const item = items[i];
+            if (typeof item !== 'object' || item === null) {
+                skipped++;
+                continue;
+            }
+            // Extract title
+            const title = item.title || item.name || item.key || `Entry ${i + 1}`;
+            // Extract content
+            let entryContent = item.content ||
+                item.text ||
+                item.description ||
+                item.value ||
+                item.memory ||
+                item.observation;
+            // Handle observations array
+            if (!entryContent && item.observations && Array.isArray(item.observations)) {
+                entryContent = item.observations.join('\n\n');
+            }
+            if (!entryContent) {
+                skipped++;
+                continue;
+            }
+            // Extract context
+            let context;
+            if (item.context) {
+                context = item.context;
+            }
+            else if (item.category) {
+                context = item.category;
+            }
+            else if (item.type) {
+                context = item.type;
+            }
+            else if (item.tags && Array.isArray(item.tags)) {
+                context = item.tags.join(', ');
+            }
+            entries.push({
+                title: String(title),
+                content: String(entryContent),
+                context,
+                intent: item.intent ? String(item.intent) : undefined,
+                reasoning: item.reasoning ? String(item.reasoning) : undefined,
+                example: item.example ? String(item.example) : undefined,
+                source: 'json',
+            });
+        }
+    }
+    catch (error) {
+        errors.push(`Failed to parse JSON: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    return { entries, skipped, errors };
+}

package/dist/library/parsers/sqlite.d.ts

@@ -0,0 +1,8 @@
+import type { ParseResult } from './types.js';
+/**
+ * Parse a SQLite database file for memory entries.
+ *
+ * Auto-detects table and column names from common patterns.
+ * Supports mcp-memory-service, SQLite-vec, and custom schemas.
+ */
+export declare function parseSQLite(filePath: string): Promise<ParseResult>;

package/dist/library/parsers/sqlite.js

@@ -0,0 +1,123 @@
+import Database from 'better-sqlite3';
+// ============================================================================
+// SQLite Parser - mcp-memory-service, SQLite-vec, custom databases
+// ============================================================================
+// Common table names for memory storage
+const TABLE_CANDIDATES = ['memories', 'entries', 'knowledge', 'notes', 'items', 'documents'];
+// Common column names for different fields
+const TITLE_CANDIDATES = ['title', 'name', 'key', 'id', 'subject', 'heading'];
+const CONTENT_CANDIDATES = ['content', 'text', 'value', 'memory', 'observation', 'body', 'description', 'note'];
+const CONTEXT_CANDIDATES = ['context', 'category', 'type', 'tags', 'topic', 'area'];
+/**
+ * Parse a SQLite database file for memory entries.
+ *
+ * Auto-detects table and column names from common patterns.
+ * Supports mcp-memory-service, SQLite-vec, and custom schemas.
+ */
+export async function parseSQLite(filePath) {
+    const entries = [];
+    const errors = [];
+    let skipped = 0;
+    let db = null;
+    try {
+        db = new Database(filePath, { readonly: true });
+        // Find a suitable table
+        const tables = db
+            .prepare("SELECT name FROM sqlite_master WHERE type='table'")
+            .all();
+        const tableNames = tables.map((t) => t.name.toLowerCase());
+        const targetTable = TABLE_CANDIDATES.find((candidate) => tableNames.includes(candidate));
+        if (!targetTable) {
+            errors.push(`No memory table found. Available tables: ${tableNames.join(', ')}. ` +
+                `Expected one of: ${TABLE_CANDIDATES.join(', ')}`);
+            return { entries, skipped, errors };
+        }
+        // Get column info for the target table
+        const columns = db.prepare(`PRAGMA table_info(${targetTable})`).all();
+        const columnNames = columns.map((c) => c.name.toLowerCase());
+        // Find content column (required)
+        const contentColumn = CONTENT_CANDIDATES.find((candidate) => columnNames.includes(candidate));
+        if (!contentColumn) {
+            errors.push(`No content column found in table "${targetTable}". ` +
+                `Available columns: ${columnNames.join(', ')}. ` +
+                `Expected one of: ${CONTENT_CANDIDATES.join(', ')}`);
+            return { entries, skipped, errors };
+        }
+        // Find optional columns
+        const titleColumn = TITLE_CANDIDATES.find((candidate) => columnNames.includes(candidate));
+        const contextColumn = CONTEXT_CANDIDATES.find((candidate) => columnNames.includes(candidate));
+        // Build and execute query
+        const selectColumns = [
+            contentColumn,
+            titleColumn,
+            contextColumn,
+        ].filter(Boolean);
+        const query = `SELECT ${selectColumns.join(', ')} FROM ${targetTable}`;
+        const rows = db.prepare(query).all();
+        for (let i = 0; i < rows.length; i++) {
+            const row = rows[i];
+            // Extract content
+            const content = row[contentColumn];
+            if (!content || typeof content !== 'string' || !content.trim()) {
+                skipped++;
+                continue;
+            }
+            // Extract title
+            let title;
+            if (titleColumn && row[titleColumn]) {
+                title = String(row[titleColumn]);
+            }
+            else {
+                // Generate title from content
+                title = content.slice(0, 60).replace(/\s+/g, ' ').trim();
+                if (content.length > 60)
+                    title += '...';
+            }
+            // Extract context
+            let context;
+            if (contextColumn && row[contextColumn]) {
+                const contextValue = row[contextColumn];
+                if (typeof contextValue === 'string') {
+                    context = contextValue;
+                }
+                else if (Array.isArray(contextValue)) {
+                    context = contextValue.join(', ');
+                }
+            }
+            entries.push({
+                title,
+                content: content.trim(),
+                context,
+                source: 'sqlite',
+                originalPath: `${filePath}:${targetTable}`,
+            });
+        }
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            if (error.message.includes('SQLITE_CANTOPEN')) {
+                errors.push(`Cannot open database file: ${filePath}`);
+            }
+            else if (error.message.includes('file is not a database')) {
+                errors.push(`File is not a valid SQLite database: ${filePath}`);
+            }
+            else {
+                errors.push(`SQLite error: ${error.message}`);
+            }
+        }
+        else {
+            errors.push(`Unknown error: ${String(error)}`);
+        }
+    }
+    finally {
+        if (db) {
+            try {
+                db.close();
+            }
+            catch {
+                // Ignore close errors
+            }
+        }
+    }
+    return { entries, skipped, errors };
+}

package/dist/library/parsers/types.d.ts

@@ -8,7 +8,7 @@ export interface ParsedEntry {
     intent?: string;
     reasoning?: string;
     example?: string;
-    source: 'jsonl' | 'markdown' | 'cursor';
+    source: 'jsonl' | 'markdown' | 'cursor' | 'json' | 'sqlite';
     originalPath?: string;
 }
 /**

package/dist/tools/import-memories.js

@@ -2,7 +2,7 @@ import * as fs from 'fs/promises';
 import * as path from 'path';
 import { getLibraryPath, getLocalPath } from '../library/storage.js';
 import { loadIndex, saveIndex, addToIndex } from '../library/vector-index.js';
-import { parseJSONL, parseMarkdown, parseCursorMemory } from '../library/parsers/index.js';
+import { parseJSONL, parseMarkdown, parseCursorMemory, parseJSON, parseSQLite } from '../library/parsers/index.js';
 // ============================================================================
 // Tool Definition
 // ============================================================================
@@ -14,19 +14,23 @@ Supported formats:
 - jsonl: Anthropic MCP Memory, mcp-knowledge-graph (.jsonl files)
 - markdown: Basic Memory, Obsidian, any .md files
 - cursor: Cursor Memory Bank (.cursor-memory/)
+- json: Simple memory servers, knowledge stores (.json files)
+- sqlite: mcp-memory-service, SQLite-vec (.db, .sqlite files)
 
 Imports go to .librarian/local/[source-name]/ and are automatically indexed for semantic search.
 
 Examples:
 - import_memories({ format: "jsonl", path: "~/.aim/memory.jsonl", source_name: "anthropic-memory" })
 - import_memories({ format: "markdown", path: "~/basic-memory/", source_name: "basic-memory" })
-- import_memories({ format: "cursor", path: ".cursor-memory/", source_name: "cursor-memory" })`,
+- import_memories({ format: "cursor", path: ".cursor-memory/", source_name: "cursor-memory" })
+- import_memories({ format: "json", path: "~/memories.json", source_name: "json-memory" })
+- import_memories({ format: "sqlite", path: "~/memory.db", source_name: "sqlite-memory" })`,
     inputSchema: {
         type: 'object',
         properties: {
             format: {
                 type: 'string',
-                enum: ['jsonl', 'markdown', 'cursor'],
+                enum: ['jsonl', 'markdown', 'cursor', 'json', 'sqlite'],
                 description: 'Format of the source memories',
             },
             path: {
@@ -74,6 +78,12 @@ Examples:
             case 'cursor':
                 parseResult = await parseCursorMemory(expandedPath);
                 break;
+            case 'json':
+                parseResult = await parseJSON(expandedPath);
+                break;
+            case 'sqlite':
+                parseResult = await parseSQLite(expandedPath);
+                break;
             default:
                 throw new Error(`Unknown format: ${format}`);
         }
@@ -133,6 +143,10 @@ function generateSourceName(format, inputPath) {
             return 'cursor-memory';
         case 'markdown':
             return basename.replace(/[^a-z0-9-]/gi, '-').toLowerCase() || 'imported-markdown';
+        case 'json':
+            return basename.replace(/[^a-z0-9-]/gi, '-').toLowerCase() || 'imported-json';
+        case 'sqlite':
+            return basename.replace(/[^a-z0-9-]/gi, '-').toLowerCase() || 'imported-sqlite';
         default:
             return `imported-${format}`;
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@telvok/librarian-mcp",
-  "version": "1.3.0",
+  "version": "1.5.0",
   "description": "Knowledge capture MCP server - remember what you learn with AI",
   "type": "module",
   "main": "dist/server.js",
@@ -33,12 +33,14 @@
   "dependencies": {
     "@huggingface/transformers": "^3.0.0",
     "@modelcontextprotocol/sdk": "^1.0.0",
+    "better-sqlite3": "^11.0.0",
     "glob": "^11.0.0",
     "gray-matter": "^4.0.3",
     "uuid": "^11.0.0",
     "zod": "^3.24.0"
   },
   "devDependencies": {
+    "@types/better-sqlite3": "^7.6.0",
     "@types/node": "^22.0.0",
     "@types/uuid": "^10.0.0",
     "typescript": "^5.7.0"