@feelingmindful/thinking-graph 1.14.1 → 1.15.0

package/dist/index.js

@@ -4,7 +4,7 @@ import { homedir } from 'os';
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
 import { ThinkingGraph } from './engine/graph.js';
-import { SQLiteAdapter } from './storage/sqlite.js';
+import { JSONLAdapter } from './storage/jsonl.js';
 import { InMemoryAdapter } from './storage/memory.js';
 import { VaultBridge } from './vault/bridge.js';
 import { thinkSchema, thinkHandler } from './tools/think.js';
@@ -26,8 +26,8 @@ function expandHome(p) {
 const memoryOnly = process.env.THINKING_GRAPH_MEMORY_ONLY === 'true';
 const storage = memoryOnly
     ? new InMemoryAdapter()
-    : new SQLiteAdapter({
-        dbPath: expandHome(process.env.THINKING_GRAPH_PROJECT_DB || '.premium/thinking.db'),
+    : new JSONLAdapter({
+        dir: expandHome(process.env.THINKING_GRAPH_DATA_DIR || '.premium/thinking'),
     });
 // ─── Vault bridge ────────────────────────────────────────
 const vaultPath = expandHome(process.env.THINKING_GRAPH_VAULT_PATH || '~/Documents/Obsidian/Dev');
@@ -70,9 +70,9 @@ async function main() {
     await server.connect(transport);
     if (!process.env.DISABLE_THOUGHT_LOGGING) {
         console.error('thinking-graph MCP server started');
-        console.error(`  Storage: ${memoryOnly ? 'in-memory' : 'SQLite'}`);
+        console.error(`  Storage: ${memoryOnly ? 'in-memory' : 'JSONL'}`);
         if (!memoryOnly) {
-            console.error(`  DB: ${process.env.THINKING_GRAPH_PROJECT_DB || '.premium/thinking.db'}`);
+            console.error(`  Dir: ${process.env.THINKING_GRAPH_DATA_DIR || '.premium/thinking'}`);
         }
         console.error(`  Vault: ${vault.root}`);
         console.error(`  Project: ${projectSlug}`);

package/dist/storage/embedding.d.ts

@@ -0,0 +1 @@
+export declare function embedText(text: string): Promise<Float32Array | null>;

package/dist/storage/embedding.js

@@ -0,0 +1,32 @@
+let pipeline = null;
+let initPromise = null;
+async function loadPipeline() {
+    try {
+        const { pipeline: createPipeline } = await import('@xenova/transformers');
+        const pipe = await createPipeline('feature-extraction', 'Xenova/bge-small-en-v1.5', {
+            quantized: true,
+        });
+        pipeline = async (text) => {
+            const output = await pipe(text, { pooling: 'mean', normalize: true });
+            return new Float32Array(output.data);
+        };
+    }
+    catch {
+        pipeline = null;
+    }
+}
+export async function embedText(text) {
+    if (process.env.THINKING_GRAPH_EMBEDDINGS === 'false')
+        return null;
+    if (!initPromise)
+        initPromise = loadPipeline();
+    await initPromise;
+    if (!pipeline)
+        return null;
+    try {
+        return await pipeline(text);
+    }
+    catch {
+        return null;
+    }
+}

package/dist/storage/jsonl.d.ts

@@ -0,0 +1,23 @@
+import type { Node, Edge, Session, SkillRegistryEntry } from '../engine/types.js';
+import { InMemoryAdapter } from './memory.js';
+export interface JSONLAdapterOpts {
+    dir: string;
+}
+export declare class JSONLAdapter extends InMemoryAdapter {
+    private readonly nodesPath;
+    private readonly edgesPath;
+    private readonly sessionsPath;
+    private readonly skillsPath;
+    private readonly embeddingsPath;
+    private readonly vectorIndex;
+    constructor(opts: JSONLAdapterOpts);
+    initialize(): Promise<void>;
+    close(): Promise<void>;
+    private maybeRunSqliteMigration;
+    insertNode(node: Node): Promise<void>;
+    searchContent(query: string): Promise<Node[]>;
+    insertEdge(edge: Edge): Promise<boolean>;
+    insertSession(session: Session): Promise<void>;
+    updateSession(id: string, fields: Partial<Session>): Promise<void>;
+    insertSkill(entry: SkillRegistryEntry): Promise<void>;
+}

package/dist/storage/jsonl.js

@@ -0,0 +1,138 @@
+import { readFileSync, appendFileSync, existsSync, mkdirSync } from 'fs';
+import { join } from 'path';
+import { InMemoryAdapter } from './memory.js';
+import { embedText } from './embedding.js';
+import { VectorIndex } from './vector-index.js';
+import { migrateSqliteToJsonl } from './migrate-sqlite.js';
+export class JSONLAdapter extends InMemoryAdapter {
+    nodesPath;
+    edgesPath;
+    sessionsPath;
+    skillsPath;
+    embeddingsPath;
+    vectorIndex = new VectorIndex();
+    constructor(opts) {
+        super();
+        this.nodesPath = join(opts.dir, 'nodes.jsonl');
+        this.edgesPath = join(opts.dir, 'edges.jsonl');
+        this.sessionsPath = join(opts.dir, 'sessions.jsonl');
+        this.skillsPath = join(opts.dir, 'skills.jsonl');
+        this.embeddingsPath = join(opts.dir, 'embeddings.ndjson');
+    }
+    async initialize() {
+        mkdirSync(join(this.nodesPath, '..'), { recursive: true });
+        await this.maybeRunSqliteMigration();
+        for (const line of readLines(this.nodesPath)) {
+            await super.insertNode(JSON.parse(line));
+        }
+        for (const line of readLines(this.edgesPath)) {
+            await super.insertEdge(JSON.parse(line));
+        }
+        // Sessions: last line wins for each id (handles updateSession appends)
+        const sessionMap = new Map();
+        for (const line of readLines(this.sessionsPath)) {
+            const s = JSON.parse(line);
+            sessionMap.set(s.id, s);
+        }
+        for (const s of sessionMap.values()) {
+            await super.insertSession(s);
+        }
+        // Skills: deduplicated by id
+        const skillMap = new Map();
+        for (const line of readLines(this.skillsPath)) {
+            const sk = JSON.parse(line);
+            skillMap.set(sk.id, sk);
+        }
+        for (const sk of skillMap.values()) {
+            await super.insertSkill(sk);
+        }
+        this.vectorIndex.load(this.embeddingsPath);
+    }
+    async close() { }
+    async maybeRunSqliteMigration() {
+        const dbPath = process.env.THINKING_GRAPH_PROJECT_DB;
+        if (!dbPath)
+            return;
+        if (!existsSync(dbPath))
+            return;
+        // Only migrate if JSONL store is empty (first run after upgrade)
+        if (existsSync(this.nodesPath))
+            return;
+        console.error(`[thinking-graph] Migrating SQLite data from ${dbPath} to JSONL...`);
+        try {
+            const counts = await migrateSqliteToJsonl({
+                dbPath,
+                nodesPath: this.nodesPath,
+                edgesPath: this.edgesPath,
+                sessionsPath: this.sessionsPath,
+                skillsPath: this.skillsPath,
+            });
+            console.error(`[thinking-graph] Migration complete: ${counts.nodes} nodes, ${counts.edges} edges, ${counts.sessions} sessions, ${counts.skills} skills`);
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            console.error(`[thinking-graph] SQLite migration skipped: ${msg}`);
+        }
+    }
+    // ─── Nodes ─────────────────────────────────────────────
+    async insertNode(node) {
+        await super.insertNode(node);
+        appendLine(this.nodesPath, node);
+        const vec = await embedText(node.content);
+        if (vec)
+            this.vectorIndex.append(this.embeddingsPath, node.id, vec);
+    }
+    async searchContent(query) {
+        const vec = await embedText(query);
+        if (!vec)
+            return super.searchContent(query);
+        const matches = this.vectorIndex.search(vec, 20).filter(m => m.score >= 0.5);
+        if (matches.length === 0)
+            return super.searchContent(query);
+        const nodes = [];
+        for (const { id } of matches) {
+            const node = await super.getNode(id);
+            if (node)
+                nodes.push(node);
+        }
+        return nodes;
+    }
+    // ─── Edges ─────────────────────────────────────────────
+    async insertEdge(edge) {
+        const created = await super.insertEdge(edge);
+        if (created)
+            appendLine(this.edgesPath, edge);
+        return created;
+    }
+    // ─── Sessions ──────────────────────────────────────────
+    async insertSession(session) {
+        await super.insertSession(session);
+        appendLine(this.sessionsPath, session);
+    }
+    async updateSession(id, fields) {
+        await super.updateSession(id, fields);
+        const updated = await super.getSession(id);
+        if (updated)
+            appendLine(this.sessionsPath, updated);
+    }
+    // ─── Skill Registry ───────────────────────────────────
+    async insertSkill(entry) {
+        // Idempotent: skip if already in memory (loaded from file or previously seeded)
+        const existing = await this.querySkills({ id: entry.id });
+        if (existing.length > 0)
+            return;
+        await super.insertSkill(entry);
+        appendLine(this.skillsPath, entry);
+    }
+}
+// ─── Helpers ───────────────────────────────────────────
+function readLines(path) {
+    if (!existsSync(path))
+        return [];
+    return readFileSync(path, 'utf-8')
+        .split('\n')
+        .filter(line => line.trim().length > 0);
+}
+function appendLine(path, value) {
+    appendFileSync(path, JSON.stringify(value) + '\n', 'utf-8');
+}

package/dist/storage/migrate-sqlite.d.ts

@@ -0,0 +1,12 @@
+export declare function migrateSqliteToJsonl(opts: {
+    dbPath: string;
+    nodesPath: string;
+    edgesPath: string;
+    sessionsPath: string;
+    skillsPath: string;
+}): Promise<{
+    nodes: number;
+    edges: number;
+    sessions: number;
+    skills: number;
+}>;

package/dist/storage/migrate-sqlite.js

@@ -0,0 +1,75 @@
+import { existsSync, appendFileSync } from 'fs';
+function appendLine(path, value) {
+    appendFileSync(path, JSON.stringify(value) + '\n', 'utf-8');
+}
+export async function migrateSqliteToJsonl(opts) {
+    if (!existsSync(opts.dbPath)) {
+        throw new Error(`SQLite database not found: ${opts.dbPath}`);
+    }
+    let Database;
+    try {
+        const mod = await import('better-sqlite3');
+        Database = mod.default;
+    }
+    catch {
+        throw new Error('better-sqlite3 not available. Install it to run migration:\n' +
+            '  npm install better-sqlite3\n' +
+            'Then retry, or migrate manually by exporting data from the old database.');
+    }
+    const db = new Database(opts.dbPath);
+    try {
+        const nodes = db.prepare('SELECT * FROM nodes').all();
+        for (const r of nodes) {
+            const node = {
+                id: r.id, type: r.type, content: r.content,
+                sessionId: r.session_id, projectId: r.project_id ?? undefined,
+                metadata: JSON.parse(r.metadata || '{}'),
+                createdAt: r.created_at, updatedAt: r.updated_at,
+                thoughtNumber: r.thought_number ?? undefined,
+                totalThoughts: r.total_thoughts ?? undefined,
+                branchId: r.branch_id ?? undefined,
+                isRevision: r.is_revision === 1,
+                revisesThought: r.revises_thought ?? undefined,
+            };
+            appendLine(opts.nodesPath, node);
+        }
+        const edges = db.prepare('SELECT * FROM edges').all();
+        for (const r of edges) {
+            const edge = {
+                id: r.id, sourceId: r.source_id, targetId: r.target_id,
+                type: r.type, weight: r.weight,
+                reasoning: r.reasoning ?? undefined, createdAt: r.created_at,
+            };
+            appendLine(opts.edgesPath, edge);
+        }
+        const sessions = db.prepare('SELECT * FROM sessions').all();
+        for (const r of sessions) {
+            const session = {
+                id: r.id, projectId: r.project_id ?? undefined,
+                projectPath: r.project_path ?? undefined,
+                description: r.description ?? undefined,
+                startedAt: r.started_at, lastActiveAt: r.last_active,
+            };
+            appendLine(opts.sessionsPath, session);
+        }
+        let skills = [];
+        try {
+            skills = db.prepare('SELECT * FROM skill_registry').all();
+        }
+        catch { /* table may not exist in older DBs */ }
+        for (const r of skills) {
+            const skill = {
+                id: r.id, pluginName: r.plugin_name, skillName: r.skill_name,
+                verb: r.verb ?? undefined, invocation: r.invocation,
+                areas: JSON.parse(r.areas), detects: JSON.parse(r.detects),
+                produces: JSON.parse(r.produces), invokes: JSON.parse(r.invokes),
+                platform: r.platform ?? undefined,
+            };
+            appendLine(opts.skillsPath, skill);
+        }
+        return { nodes: nodes.length, edges: edges.length, sessions: sessions.length, skills: skills.length };
+    }
+    finally {
+        db.close();
+    }
+}

package/dist/storage/vector-index.d.ts

@@ -0,0 +1,11 @@
+export interface VectorMatch {
+    id: string;
+    score: number;
+}
+export declare class VectorIndex {
+    private readonly vectors;
+    load(path: string): void;
+    append(path: string, id: string, vec: Float32Array): void;
+    search(queryVec: Float32Array, topK: number): VectorMatch[];
+    has(id: string): boolean;
+}

package/dist/storage/vector-index.js

@@ -0,0 +1,35 @@
+import { readFileSync, appendFileSync, existsSync } from 'fs';
+export class VectorIndex {
+    vectors = new Map();
+    load(path) {
+        if (!existsSync(path))
+            return;
+        for (const line of readFileSync(path, 'utf-8').split('\n')) {
+            if (!line.trim())
+                continue;
+            const { id, vec } = JSON.parse(line);
+            this.vectors.set(id, new Float32Array(vec));
+        }
+    }
+    append(path, id, vec) {
+        this.vectors.set(id, vec);
+        appendFileSync(path, JSON.stringify({ id, vec: Array.from(vec) }) + '\n', 'utf-8');
+    }
+    search(queryVec, topK) {
+        const results = [];
+        for (const [id, vec] of this.vectors) {
+            results.push({ id, score: dot(queryVec, vec) });
+        }
+        results.sort((a, b) => b.score - a.score);
+        return results.slice(0, topK);
+    }
+    has(id) {
+        return this.vectors.has(id);
+    }
+}
+function dot(a, b) {
+    let sum = 0;
+    for (let i = 0; i < a.length; i++)
+        sum += a[i] * b[i];
+    return sum;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@feelingmindful/thinking-graph",
-  "version": "1.14.1",
+  "version": "1.15.0",
   "description": "Persistent graph-based MCP thinking server for the feeling-mindful plugin marketplace",
   "type": "module",
   "main": "dist/index.js",
@@ -31,8 +31,8 @@
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.12.0",
+    "@xenova/transformers": "^2.17.2",
     "ajv": "^8.17.1",
-    "better-sqlite3": "^12.8.0",
     "gray-matter": "^4.0.3",
     "uuid": "^10.0.0",
     "zod": "^3.23.0"
@@ -41,6 +41,7 @@
     "@types/better-sqlite3": "^7.6.13",
     "@types/node": "^25.5.0",
     "@types/uuid": "^10.0.0",
+    "better-sqlite3": "^12.8.0",
     "typescript": "^5.5.0",
     "vitest": "^3.0.0"
   }