@feelingmindful/thinking-graph 1.11.0 → 1.13.0

package/dist/engine/seed.js

@@ -37,6 +37,17 @@ export async function seedSkillRegistry(storage) {
     return count;
 }
 export async function seedAll(storage) {
+    // Ensure a 'seed' session exists for FK constraint on seed nodes
+    const seedSession = await storage.getSession('seed');
+    if (!seedSession) {
+        const now = new Date().toISOString();
+        await storage.insertSession({
+            id: 'seed',
+            description: 'Seed data session',
+            startedAt: now,
+            lastActiveAt: now,
+        });
+    }
     const principles = await seedPrinciples(storage);
     const skills = await seedSkillRegistry(storage);
     return { principles, skills };

package/dist/index.js

@@ -1,4 +1,6 @@
 #!/usr/bin/env node
+import { join } from 'path';
+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';
@@ -17,15 +19,18 @@ import { planSkillsSchema, planSkillsHandler } from './tools/plan-skills.js';
 import { executePlanSchema, executePlanHandler } from './tools/execute-plan.js';
 import { executeSkillsSchema, executeSkillsHandler } from './tools/execute-skills.js';
 // Legacy compat shim removed — use `think` tool directly
+function expandHome(p) {
+    return p.startsWith('~') ? join(homedir(), p.slice(1)) : p;
+}
 // ─── Storage setup ───────────────────────────────────────
 const memoryOnly = process.env.THINKING_GRAPH_MEMORY_ONLY === 'true';
 const storage = memoryOnly
     ? new InMemoryAdapter()
     : new SQLiteAdapter({
-        dbPath: process.env.THINKING_GRAPH_PROJECT_DB || '.premium/thinking.db',
+        dbPath: expandHome(process.env.THINKING_GRAPH_PROJECT_DB || '.premium/thinking.db'),
     });
 // ─── Vault bridge ────────────────────────────────────────
-const vaultPath = process.env.THINKING_GRAPH_VAULT_PATH || '~/Documents/Obsidian/Dev';
+const vaultPath = expandHome(process.env.THINKING_GRAPH_VAULT_PATH || '~/Documents/Obsidian/Dev');
 const vault = new VaultBridge(vaultPath);
 // Derive project slug from env or DB path (e.g. "feeling-mindful-plugins")
 const projectSlug = process.env.THINKING_GRAPH_PROJECT_SLUG

package/dist/storage/sqlite.d.ts

@@ -5,14 +5,14 @@ export interface SQLiteAdapterOpts {
 }
 export declare class SQLiteAdapter implements StorageAdapter {
     private db;
-    private dbPath;
+    private readonly dbPath;
     constructor(opts: SQLiteAdapterOpts);
     initialize(): Promise<void>;
     close(): Promise<void>;
-    private persist;
-    private runSql;
-    private getSingle;
-    private getAll;
+    private backfillFts;
+    private run;
+    private get;
+    private all;
     insertNode(node: Node): Promise<void>;
     getNode(id: string): Promise<Node | null>;
     queryNodes(query: NodeQuery): Promise<PaginatedResult<Node>>;

package/dist/storage/sqlite.js

@@ -1,17 +1,10 @@
-import initSqlJs from 'sql.js';
-import { readFileSync, writeFileSync, existsSync } from 'fs';
+import Database from 'better-sqlite3';
+import { readFileSync } from 'fs';
 import { join, dirname } from 'path';
 import { mkdirSync } from 'fs';
 import { fileURLToPath } from 'url';
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const MIGRATION_PATH = join(__dirname, '../../migrations/001-initial.sql');
-// Cache the WASM module so multiple instances don't re-initialize Emscripten
-let sqlJsPromise = null;
-function getSqlJs() {
-    if (!sqlJsPromise)
-        sqlJsPromise = initSqlJs();
-    return sqlJsPromise;
-}
 export class SQLiteAdapter {
     db;
     dbPath;
@@ -21,72 +14,39 @@ export class SQLiteAdapter {
     async initialize() {
         const dir = dirname(this.dbPath);
         mkdirSync(dir, { recursive: true });
-        const SQL = await getSqlJs();
-        if (existsSync(this.dbPath)) {
-            const fileBuffer = readFileSync(this.dbPath);
-            this.db = new SQL.Database(new Uint8Array(fileBuffer));
-        }
-        else {
-            this.db = new SQL.Database();
-        }
-        this.db.run('PRAGMA foreign_keys = ON');
-        // sql.js uses db.export() which serializes the full DB — WAL mode is not
-        // supported and causes data loss. Force DELETE journal mode.
-        this.db.run('PRAGMA journal_mode = DELETE');
+        this.db = new Database(this.dbPath);
+        this.db.pragma('journal_mode = WAL');
+        this.db.pragma('foreign_keys = ON');
+        this.db.pragma('busy_timeout = 5000');
         // Run migration (multi-statement)
         const sql = readFileSync(MIGRATION_PATH, 'utf-8');
         this.db.exec(sql);
-        this.persist();
+        // Backfill FTS5 if nodes exist but index is empty
+        this.backfillFts();
     }
     async close() {
-        this.persist();
         this.db.close();
     }
-    persist() {
-        const data = this.db.export();
-        const buffer = Buffer.from(data);
-        writeFileSync(this.dbPath, buffer);
+    backfillFts() {
+        const ftsCount = this.db.prepare('SELECT COUNT(*) as cnt FROM nodes_fts').get().cnt;
+        const nodeCount = this.db.prepare('SELECT COUNT(*) as cnt FROM nodes').get().cnt;
+        if (ftsCount === 0 && nodeCount > 0) {
+            this.db.exec('INSERT INTO nodes_fts(rowid, content) SELECT rowid, content FROM nodes');
+        }
     }
     // ─── Helpers ──────────────────────────────────────────
-    runSql(sql, params = []) {
-        this.db.run(sql, params);
-        this.persist();
+    run(sql, params = []) {
+        this.db.prepare(sql).run(...params);
     }
-    getSingle(sql, params = []) {
-        const stmt = this.db.prepare(sql);
-        stmt.bind(params);
-        if (stmt.step()) {
-            const columns = stmt.getColumnNames();
-            const values = stmt.get();
-            stmt.free();
-            const row = {};
-            for (let i = 0; i < columns.length; i++) {
-                row[columns[i]] = values[i];
-            }
-            return row;
-        }
-        stmt.free();
-        return undefined;
+    get(sql, params = []) {
+        return this.db.prepare(sql).get(...params);
     }
-    getAll(sql, params = []) {
-        const stmt = this.db.prepare(sql);
-        stmt.bind(params);
-        const rows = [];
-        while (stmt.step()) {
-            const columns = stmt.getColumnNames();
-            const values = stmt.get();
-            const row = {};
-            for (let i = 0; i < columns.length; i++) {
-                row[columns[i]] = values[i];
-            }
-            rows.push(row);
-        }
-        stmt.free();
-        return rows;
+    all(sql, params = []) {
+        return this.db.prepare(sql).all(...params);
     }
     // ─── Nodes ─────────────────────────────────────────────
     async insertNode(node) {
-        this.runSql(`
+        this.run(`
       INSERT INTO nodes (id, type, content, session_id, project_id, metadata,
         created_at, updated_at, thought_number, total_thoughts, branch_id,
         is_revision, revises_thought)
@@ -100,7 +60,7 @@ export class SQLiteAdapter {
         ]);
     }
     async getNode(id) {
-        const row = this.getSingle('SELECT * FROM nodes WHERE id = ?', [id]);
+        const row = this.get('SELECT * FROM nodes WHERE id = ?', [id]);
         return row ? this.rowToNode(row) : null;
     }
     async queryNodes(query) {
@@ -128,11 +88,11 @@ export class SQLiteAdapter {
             params.push(`%${query.query}%`);
         }
         const where = conditions.length > 0 ? `WHERE ${conditions.join(' AND ')}` : '';
-        const countRow = this.getSingle(`SELECT COUNT(*) as cnt FROM nodes ${where}`, params);
+        const countRow = this.get(`SELECT COUNT(*) as cnt FROM nodes ${where}`, params);
         const totalCount = countRow.cnt;
         const limit = query.limit ?? 20;
         const offset = query.offset ?? 0;
-        const rows = this.getAll(`SELECT * FROM nodes ${where} ORDER BY created_at DESC LIMIT ? OFFSET ?`, [...params, limit, offset]);
+        const rows = this.all(`SELECT * FROM nodes ${where} ORDER BY created_at DESC LIMIT ? OFFSET ?`, [...params, limit, offset]);
         return {
             items: rows.map(r => this.rowToNode(r)),
             totalCount,
@@ -140,18 +100,27 @@ export class SQLiteAdapter {
         };
     }
     async searchContent(text, limit = 20) {
-        const rows = this.getAll(`
-      SELECT * FROM nodes
-      WHERE content LIKE ?
-      ORDER BY created_at DESC
-      LIMIT ?
-    `, [`%${text}%`, limit]);
-        return rows.map(r => this.rowToNode(r));
+        try {
+            const rows = this.all(`
+        SELECT n.* FROM nodes n
+        WHERE n.rowid IN (SELECT rowid FROM nodes_fts WHERE nodes_fts MATCH ?)
+        ORDER BY n.created_at DESC
+        LIMIT ?
+      `, [text, limit]);
+            return rows.map(r => this.rowToNode(r));
+        }
+        catch {
+            // Fallback for queries that aren't valid FTS5 syntax
+            const rows = this.all(`
+        SELECT * FROM nodes WHERE content LIKE ? ORDER BY created_at DESC LIMIT ?
+      `, [`%${text}%`, limit]);
+            return rows.map(r => this.rowToNode(r));
+        }
     }
     // ─── Edges ─────────────────────────────────────────────
     async insertEdge(edge) {
         try {
-            this.runSql(`
+            this.run(`
         INSERT INTO edges (id, source_id, target_id, type, weight, reasoning, created_at)
         VALUES (?, ?, ?, ?, ?, ?, ?)
       `, [
@@ -172,19 +141,17 @@ export class SQLiteAdapter {
             ? 'SELECT * FROM edges WHERE source_id = ? AND type = ?'
             : 'SELECT * FROM edges WHERE source_id = ?';
         const params = type ? [nodeId, type] : [nodeId];
-        const rows = this.getAll(sql, params);
-        return rows.map(r => this.rowToEdge(r));
+        return this.all(sql, params).map(r => this.rowToEdge(r));
     }
     async getEdgesTo(nodeId, type) {
         const sql = type
             ? 'SELECT * FROM edges WHERE target_id = ? AND type = ?'
             : 'SELECT * FROM edges WHERE target_id = ?';
         const params = type ? [nodeId, type] : [nodeId];
-        const rows = this.getAll(sql, params);
-        return rows.map(r => this.rowToEdge(r));
+        return this.all(sql, params).map(r => this.rowToEdge(r));
     }
     async traverseEdges(startId, type, maxDepth) {
-        const rows = this.getAll(`
+        const rows = this.all(`
       WITH RECURSIVE chain(id, depth) AS (
         SELECT target_id, 1
         FROM edges
@@ -203,7 +170,7 @@ export class SQLiteAdapter {
     }
     // ─── Sessions ──────────────────────────────────────────
     async insertSession(session) {
-        this.runSql(`
+        this.run(`
       INSERT INTO sessions (id, project_id, project_path, description, started_at, last_active)
       VALUES (?, ?, ?, ?, ?, ?)
     `, [
@@ -212,7 +179,7 @@ export class SQLiteAdapter {
         ]);
     }
     async getSession(id) {
-        const row = this.getSingle('SELECT * FROM sessions WHERE id = ?', [id]);
+        const row = this.get('SELECT * FROM sessions WHERE id = ?', [id]);
         return row ? this.rowToSession(row) : null;
     }
     async updateSession(id, fields) {
@@ -228,12 +195,12 @@ export class SQLiteAdapter {
         }
         if (sets.length > 0) {
             params.push(id);
-            this.runSql(`UPDATE sessions SET ${sets.join(', ')} WHERE id = ?`, params);
+            this.run(`UPDATE sessions SET ${sets.join(', ')} WHERE id = ?`, params);
         }
     }
     // ─── Skill Registry ───────────────────────────────────
     async insertSkill(entry) {
-        this.runSql(`
+        this.run(`
       INSERT OR IGNORE INTO skill_registry
         (id, plugin_name, skill_name, verb, invocation, areas, detects, produces, invokes, platform)
       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
@@ -267,7 +234,7 @@ export class SQLiteAdapter {
             params.push(filter.platform);
         }
         const where = conditions.length > 0 ? `WHERE ${conditions.join(' AND ')}` : '';
-        const rows = this.getAll(`SELECT * FROM skill_registry ${where}`, params);
+        const rows = this.all(`SELECT * FROM skill_registry ${where}`, params);
         return rows.map(r => ({
             id: r.id,
             pluginName: r.plugin_name,
@@ -299,18 +266,18 @@ export class SQLiteAdapter {
             params.push(...types);
         }
         const where = conditions.length > 0 ? `WHERE ${conditions.join(' AND ')}` : '';
-        const nodeRows = this.getAll(`SELECT * FROM nodes ${where}`, params);
+        const nodeRows = this.all(`SELECT * FROM nodes ${where}`, params);
         const nodes = nodeRows.map(r => this.rowToNode(r));
         let edges = [];
         if (opts?.includeEdges !== false) {
             const nodeIds = nodes.map(n => n.id);
             if (nodeIds.length > 0) {
                 const placeholders = nodeIds.map(() => '?').join(',');
-                const edgeRows = this.getAll(`SELECT * FROM edges WHERE source_id IN (${placeholders}) OR target_id IN (${placeholders})`, [...nodeIds, ...nodeIds]);
+                const edgeRows = this.all(`SELECT * FROM edges WHERE source_id IN (${placeholders}) OR target_id IN (${placeholders})`, [...nodeIds, ...nodeIds]);
                 edges = edgeRows.map(r => this.rowToEdge(r));
             }
         }
-        const sessionRows = this.getAll('SELECT * FROM sessions');
+        const sessionRows = this.all('SELECT * FROM sessions');
         return {
             exportedAt: new Date().toISOString(),
             nodeCount: nodes.length,
@@ -323,15 +290,15 @@ export class SQLiteAdapter {
     // ─── Stats ─────────────────────────────────────────────
     async getStats() {
         const nodesByType = {};
-        const ntRows = this.getAll('SELECT type, COUNT(*) as cnt FROM nodes GROUP BY type');
+        const ntRows = this.all('SELECT type, COUNT(*) as cnt FROM nodes GROUP BY type');
         for (const r of ntRows)
             nodesByType[r.type] = r.cnt;
         const edgesByType = {};
-        const etRows = this.getAll('SELECT type, COUNT(*) as cnt FROM edges GROUP BY type');
+        const etRows = this.all('SELECT type, COUNT(*) as cnt FROM edges GROUP BY type');
         for (const r of etRows)
             edgesByType[r.type] = r.cnt;
-        const totalNodes = this.getSingle('SELECT COUNT(*) as cnt FROM nodes').cnt;
-        const totalEdges = this.getSingle('SELECT COUNT(*) as cnt FROM edges').cnt;
+        const totalNodes = this.get('SELECT COUNT(*) as cnt FROM nodes').cnt;
+        const totalEdges = this.get('SELECT COUNT(*) as cnt FROM edges').cnt;
         return {
             totalNodes,
             totalEdges,

package/dist/tools/research.d.ts

@@ -3,7 +3,7 @@ import type { ThinkingGraph } from '../engine/graph.js';
 import { type VaultBridge } from '../vault/bridge.js';
 export declare const researchSchema: z.ZodObject<{
     query: z.ZodString;
-    intent: z.ZodDefault<z.ZodEnum<["fact_check", "explore", "compare", "how_to", "current_state"]>>;
+    intent: z.ZodDefault<z.ZodEnum<["fact_check", "explore", "compare", "how_to", "current_state", "grounded_qa"]>>;
     context: z.ZodOptional<z.ZodString>;
     researchId: z.ZodOptional<z.ZodString>;
     findings: z.ZodOptional<z.ZodArray<z.ZodObject<{
@@ -23,9 +23,11 @@ export declare const researchSchema: z.ZodObject<{
     scrapeUrls: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
     recencyFilter: z.ZodOptional<z.ZodEnum<["hour", "day", "week", "month", "year"]>>;
     domainFilter: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    notebookId: z.ZodOptional<z.ZodString>;
+    skipGrounded: z.ZodOptional<z.ZodEffects<z.ZodBoolean, boolean, unknown>>;
 }, "strip", z.ZodTypeAny, {
     query: string;
-    intent: "fact_check" | "explore" | "compare" | "how_to" | "current_state";
+    intent: "fact_check" | "explore" | "compare" | "how_to" | "current_state" | "grounded_qa";
     projectId?: string | undefined;
     context?: string | undefined;
     researchId?: string | undefined;
@@ -37,10 +39,12 @@ export declare const researchSchema: z.ZodObject<{
     scrapeUrls?: string[] | undefined;
     recencyFilter?: "hour" | "day" | "week" | "month" | "year" | undefined;
     domainFilter?: string[] | undefined;
+    notebookId?: string | undefined;
+    skipGrounded?: boolean | undefined;
 }, {
     query: string;
     projectId?: string | undefined;
-    intent?: "fact_check" | "explore" | "compare" | "how_to" | "current_state" | undefined;
+    intent?: "fact_check" | "explore" | "compare" | "how_to" | "current_state" | "grounded_qa" | undefined;
     context?: string | undefined;
     researchId?: string | undefined;
     findings?: {
@@ -51,6 +55,8 @@ export declare const researchSchema: z.ZodObject<{
     scrapeUrls?: string[] | undefined;
     recencyFilter?: "hour" | "day" | "week" | "month" | "year" | undefined;
     domainFilter?: string[] | undefined;
+    notebookId?: string | undefined;
+    skipGrounded?: unknown;
 }>;
 export type ResearchInput = z.infer<typeof researchSchema>;
 export declare function researchHandler(graph: ThinkingGraph, input: ResearchInput, vault?: VaultBridge, projectSlug?: string): Promise<{

package/dist/tools/research.js

@@ -7,7 +7,11 @@ const RESEARCH_INTENTS = [
     'compare', // Compare options, libraries, approaches
     'how_to', // Find implementation guidance
     'current_state', // Get current state of something (version, status, etc.)
+    'grounded_qa', // Query a curated knowledge base (NotebookLM notebook) — zero hallucinations
 ];
+// Intents that should preferentially route through a NotebookLM notebook when available.
+// These are the cases where a curated, citation-backed source is most valuable.
+const GROUNDED_PREFERRED_INTENTS = new Set(['how_to', 'fact_check', 'current_state', 'grounded_qa']);
 const findingSchema = z.object({
     content: z.string().describe('What was found'),
     source: z.string().optional().describe('URL or citation'),
@@ -26,10 +30,51 @@ export const researchSchema = z.object({
     scrapeUrls: z.array(z.string()).optional().describe('Specific URLs to scrape with Firecrawl'),
     recencyFilter: z.enum(['hour', 'day', 'week', 'month', 'year']).optional().describe('How recent results should be'),
     domainFilter: z.array(z.string()).optional().describe('Restrict to these domains'),
+    notebookId: z.string().optional().describe('Specific NotebookLM notebook ID to query. If omitted, action plan will list notebooks first so the caller can pick the best match.'),
+    skipGrounded: coerceBool.optional().describe('Skip NotebookLM step even when it would normally auto-prepend'),
 });
+function buildGroundedSteps(input) {
+    const steps = [];
+    const query = input.query;
+    // If caller specified a notebookId, select it then ask directly.
+    if (input.notebookId) {
+        steps.push({
+            tool: 'mcp__notebooklm__select_notebook',
+            description: 'Select the specified NotebookLM notebook',
+            args: { id: input.notebookId },
+        });
+        steps.push({
+            tool: 'mcp__notebooklm__ask_question',
+            description: 'Ask NotebookLM (grounded, citation-backed)',
+            args: { question: query },
+        });
+        return steps;
+    }
+    // Otherwise: search the library for the best match, then the agent picks one and asks.
+    steps.push({
+        tool: 'mcp__notebooklm__search_notebooks',
+        description: 'Find a NotebookLM notebook matching this query. Skip remaining NotebookLM steps if no match.',
+        args: { query },
+    });
+    steps.push({
+        tool: 'mcp__notebooklm__ask_question',
+        description: 'Ask the selected NotebookLM notebook. Only run after search_notebooks returns a match; fall back to the web-grounded steps below if the library has no relevant notebook.',
+        args: { question: query },
+    });
+    return steps;
+}
 function buildActionPlan(input) {
     const steps = [];
     const query = input.query;
+    // Grounded NotebookLM path (preferred for how_to / fact_check / current_state / grounded_qa).
+    const shouldPrependGrounded = !input.skipGrounded && GROUNDED_PREFERRED_INTENTS.has(input.intent ?? 'explore');
+    if (shouldPrependGrounded) {
+        steps.push(...buildGroundedSteps(input));
+    }
+    // grounded_qa is NotebookLM-only — no web fallback steps.
+    if (input.intent === 'grounded_qa') {
+        return steps;
+    }
     // Choose Perplexity tool based on intent
     switch (input.intent) {
         case 'fact_check':

package/migrations/001-initial.sql

@@ -84,3 +84,24 @@ CREATE TABLE IF NOT EXISTS skill_registry (
 
   UNIQUE(plugin_name, skill_name)
 );
+
+-- ─── Full-Text Search ────────────────────────────────────
+
+CREATE VIRTUAL TABLE IF NOT EXISTS nodes_fts USING fts5(
+  content,
+  content='nodes',
+  content_rowid='rowid'
+);
+
+CREATE TRIGGER IF NOT EXISTS nodes_ai AFTER INSERT ON nodes BEGIN
+  INSERT INTO nodes_fts(rowid, content) VALUES (new.rowid, new.content);
+END;
+
+CREATE TRIGGER IF NOT EXISTS nodes_au AFTER UPDATE ON nodes BEGIN
+  INSERT INTO nodes_fts(nodes_fts, rowid, content) VALUES ('delete', old.rowid, old.content);
+  INSERT INTO nodes_fts(rowid, content) VALUES (new.rowid, new.content);
+END;
+
+CREATE TRIGGER IF NOT EXISTS nodes_ad AFTER DELETE ON nodes BEGIN
+  INSERT INTO nodes_fts(nodes_fts, rowid, content) VALUES ('delete', old.rowid, old.content);
+END;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@feelingmindful/thinking-graph",
-  "version": "1.11.0",
+  "version": "1.13.0",
   "description": "Persistent graph-based MCP thinking server for the feeling-mindful plugin marketplace",
   "type": "module",
   "main": "dist/index.js",
@@ -31,12 +31,13 @@
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.12.0",
+    "better-sqlite3": "^12.8.0",
     "gray-matter": "^4.0.3",
-    "sql.js": "^1.12.0",
     "uuid": "^10.0.0",
     "zod": "^3.23.0"
   },
   "devDependencies": {
+    "@types/better-sqlite3": "^7.6.13",
     "@types/node": "^25.5.0",
     "@types/uuid": "^10.0.0",
     "typescript": "^5.5.0",