@feelingmindful/thinking-graph 1.9.0 → 1.10.0

package/dist/index.js

@@ -4,6 +4,7 @@ import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js'
 import { ThinkingGraph } from './engine/graph.js';
 import { SQLiteAdapter } from './storage/sqlite.js';
 import { InMemoryAdapter } from './storage/memory.js';
+import { VaultBridge } from './vault/bridge.js';
 import { thinkSchema, thinkHandler } from './tools/think.js';
 import { relateSchema, relateHandler } from './tools/relate.js';
 import { recallSchema, recallHandler } from './tools/recall.js';
@@ -19,6 +20,20 @@ const storage = memoryOnly
     : new SQLiteAdapter({
         dbPath: process.env.THINKING_GRAPH_PROJECT_DB || '.premium/thinking.db',
     });
+// ─── Vault bridge ────────────────────────────────────────
+const vaultPath = 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
+    || deriveProjectSlug(process.env.THINKING_GRAPH_PROJECT_DB || '');
+function deriveProjectSlug(dbPath) {
+    // Try CWD-based slug: last segment of the working directory
+    const cwd = process.cwd();
+    const segments = cwd.split('/').filter(Boolean);
+    if (segments.length > 0)
+        return segments[segments.length - 1];
+    return 'default';
+}
 // ─── Graph engine ────────────────────────────────────────
 const graph = new ThinkingGraph(storage);
 // ─── MCP Server ──────────────────────────────────────────
@@ -29,10 +44,10 @@ const server = new McpServer({
 // Register new tools
 server.tool('think', 'Record a reasoning step with optional typing, relationships, and metadata. Enhanced version of sequential thinking.', thinkSchema.shape, async (input) => thinkHandler(graph, input));
 server.tool('relate', 'Create a typed, directional relationship between two nodes in the thinking graph.', relateSchema.shape, async (input) => relateHandler(graph, input));
-server.tool('recall', 'Query the thinking graph — search by text, filter by type, traverse relationships, or search across projects.', recallSchema.shape, async (input) => recallHandler(graph, input));
-server.tool('learn', 'Store durable knowledge — code facts, tech debt, insights, principles. Deduplicates similar content.', learnSchema.shape, async (input) => learnHandler(graph, input));
+server.tool('recall', 'Query the thinking graph and Obsidian vault — search by text, filter by type, traverse relationships, or search across projects.', recallSchema.shape, async (input) => recallHandler(graph, input, vault, projectSlug));
+server.tool('learn', 'Store durable knowledge — code facts, tech debt, insights, principles. Writes to both SQLite graph and Obsidian vault.', learnSchema.shape, async (input) => learnHandler(graph, input, vault, projectSlug));
 server.tool('export', 'Export the thinking graph as JSON or a human-readable markdown summary.', exportSchema.shape, async (input) => exportHandler(graph, input));
-server.tool('research', 'Research a topic using Perplexity/Firecrawl, then ingest findings into the graph. Two-phase: call once to get an action plan, then again with findings to store them.', researchSchema.shape, async (input) => researchHandler(graph, input));
+server.tool('research', 'Research a topic using Perplexity/Firecrawl, then ingest findings into the graph and Obsidian vault. Two-phase: call once to get an action plan, then again with findings to store them.', researchSchema.shape, async (input) => researchHandler(graph, input, vault, projectSlug));
 server.tool('recommend-skills', 'Recommend installed marketplace skills by area, verb, platform, or what they produce/detect. Use during reasoning to find skills that can help with the current task.', recommendSkillsSchema.shape, async (input) => recommendSkillsHandler(graph, input));
 // ─── Startup ─────────────────────────────────────────────
 async function main() {
@@ -46,6 +61,8 @@ async function main() {
         if (!memoryOnly) {
             console.error(`  DB: ${process.env.THINKING_GRAPH_PROJECT_DB || '.premium/thinking.db'}`);
         }
+        console.error(`  Vault: ${vault.root}`);
+        console.error(`  Project: ${projectSlug}`);
     }
 }
 main().catch((err) => {

package/dist/tools/learn.d.ts

@@ -1,5 +1,6 @@
 import { z } from 'zod';
 import type { ThinkingGraph } from '../engine/graph.js';
+import type { VaultBridge } from '../vault/bridge.js';
 export declare const learnSchema: z.ZodObject<{
     content: z.ZodString;
     type: z.ZodEnum<["thought", "decision", "insight", "code_fact", "assumption", "detection", "tech_debt", "principle", "pattern", "skill_result", "research"]>;
@@ -58,7 +59,7 @@ export declare const learnSchema: z.ZodObject<{
     violatedBy?: string[] | undefined;
 }>;
 export type LearnInput = z.infer<typeof learnSchema>;
-export declare function learnHandler(graph: ThinkingGraph, input: LearnInput): Promise<{
+export declare function learnHandler(graph: ThinkingGraph, input: LearnInput, vault?: VaultBridge, projectSlug?: string): Promise<{
     content: {
         type: "text";
         text: string;

package/dist/tools/learn.js

@@ -1,5 +1,5 @@
 import { z } from 'zod';
-import { NODE_TYPES, EDGE_TYPES, GLOBAL_NODE_TYPES } from '../engine/types.js';
+import { NODE_TYPES, EDGE_TYPES } from '../engine/types.js';
 export const learnSchema = z.object({
     content: z.string().describe('What was learned'),
     type: z.enum(NODE_TYPES).describe('Node type'),
@@ -17,7 +17,7 @@ export const learnSchema = z.object({
     violatedBy: z.array(z.string()).optional().describe('Node IDs violating this'),
     metadata: z.record(z.unknown()).optional(),
 });
-export async function learnHandler(graph, input) {
+export async function learnHandler(graph, input, vault, projectSlug) {
     // Check for duplicate
     const existing = await graph.findSimilar(input.content, input.type, input.projectId);
     if (existing) {
@@ -77,39 +77,29 @@ export async function learnHandler(graph, input) {
             relatedCount++;
         }
     }
-    // Suggest writing to the knowledge-graph vault for durable, cross-project knowledge
-    const suggestions = [];
-    if (GLOBAL_NODE_TYPES.includes(input.type)) {
-        suggestions.push({
-            tool: 'kg_create_node',
-            when: 'Persist this to the knowledge vault for semantic search, community detection, and cross-project discovery',
-            example: {
-                title: input.content.slice(0, 60).replace(/[^a-zA-Z0-9 ]/g, ''),
-                directory: input.type === 'insight' ? 'Insights' : input.type === 'pattern' ? 'Patterns' : 'Principles',
+    // Write to Obsidian vault (project-scoped)
+    let vaultPath = null;
+    if (vault && projectSlug) {
+        try {
+            const title = input.content.slice(0, 80).replace(/[^a-zA-Z0-9 ]/g, '').trim() || input.type;
+            vaultPath = vault.write({
+                title,
+                type: input.type,
                 content: input.content,
-                frontmatter: {
-                    type: input.type,
-                    tags: [input.type],
-                    ...(input.projectId && { project: input.projectId }),
-                },
-            },
-        });
-    }
-    if (input.type === 'code_fact' && input.filePath) {
-        suggestions.push({
-            tool: 'kg_create_node',
-            when: 'Persist this code fact to the knowledge vault for future recall across projects',
-            example: {
-                title: input.content.slice(0, 60).replace(/[^a-zA-Z0-9 ]/g, ''),
-                directory: 'Code Facts',
-                content: input.content,
-                frontmatter: {
-                    type: 'code_fact',
-                    filePath: input.filePath,
-                    tags: ['code-fact'],
+                projectSlug,
+                metadata: {
+                    nodeId: node.id,
+                    ...(input.filePath && { filePath: input.filePath }),
+                    ...(input.severity && { severity: input.severity }),
+                    ...(input.effort && { effort: input.effort }),
+                    ...(input.impact && { impact: input.impact }),
                 },
-            },
-        });
+            });
+        }
+        catch (err) {
+            // Non-fatal — log and continue
+            console.error('Vault write failed:', err);
+        }
     }
     return {
         content: [{
@@ -119,7 +109,7 @@ export async function learnHandler(graph, input) {
                     type: node.type,
                     relatedCount,
                     duplicateOf: null,
-                    ...(suggestions.length > 0 && { suggestions }),
+                    ...(vaultPath && { vaultPath }),
                 }),
             }],
     };

package/dist/tools/recall.d.ts

@@ -1,5 +1,6 @@
 import { z } from 'zod';
 import type { ThinkingGraph } from '../engine/graph.js';
+import type { VaultBridge } from '../vault/bridge.js';
 export declare const recallSchema: z.ZodObject<{
     query: z.ZodOptional<z.ZodString>;
     type: z.ZodOptional<z.ZodUnion<[z.ZodEnum<["thought", "decision", "insight", "code_fact", "assumption", "detection", "tech_debt", "principle", "pattern", "skill_result", "research"]>, z.ZodArray<z.ZodEnum<["thought", "decision", "insight", "code_fact", "assumption", "detection", "tech_debt", "principle", "pattern", "skill_result", "research"]>, "many">]>>;
@@ -44,7 +45,7 @@ export declare const recallSchema: z.ZodObject<{
     offset?: number | undefined;
 }>;
 export type RecallInput = z.infer<typeof recallSchema>;
-export declare function recallHandler(graph: ThinkingGraph, input: RecallInput): Promise<{
+export declare function recallHandler(graph: ThinkingGraph, input: RecallInput, vault?: VaultBridge, projectSlug?: string): Promise<{
     content: {
         type: "text";
         text: string;

package/dist/tools/recall.js

@@ -16,15 +16,14 @@ export const recallSchema = z.object({
     limit: z.coerce.number().int().min(1).max(100).optional(),
     offset: z.coerce.number().int().min(0).optional(),
 });
-export async function recallHandler(graph, input) {
-    // If relatedTo is specified, use graph traversal
+export async function recallHandler(graph, input, vault, projectSlug) {
+    // If relatedTo is specified, use graph traversal (no vault merge needed)
     if (input.relatedTo) {
         const edgeType = input.edgeType
             ? (Array.isArray(input.edgeType) ? input.edgeType[0] : input.edgeType)
             : 'depends_on';
         const depth = input.depth ?? 1;
         const nodes = await graph.traverse(input.relatedTo, edgeType, depth);
-        // Enrich with edge previews
         const enriched = await Promise.all(nodes.slice(0, input.limit ?? 20).map(n => graph.getNodeWithEdges(n.id)));
         return {
             content: [{
@@ -37,7 +36,7 @@ export async function recallHandler(graph, input) {
                 }],
         };
     }
-    // Standard query
+    // Standard query — search SQLite graph
     const result = await graph.findNodes({
         query: input.query,
         type: input.type,
@@ -49,8 +48,18 @@ export async function recallHandler(graph, input) {
         limit: input.limit,
         offset: input.offset,
     });
-    // Enrich each node with 1-depth edge preview
     const enriched = await Promise.all(result.items.map(n => graph.getNodeWithEdges(n.id)));
+    // Also search Obsidian vault if query text is provided
+    let vaultResults = [];
+    if (vault && projectSlug && input.query) {
+        const typeFilter = input.type
+            ? (Array.isArray(input.type) ? input.type[0] : input.type)
+            : undefined;
+        vaultResults = vault.search(input.query, projectSlug, {
+            limit: input.limit ?? 20,
+            type: typeFilter,
+        });
+    }
     return {
         content: [{
                 type: 'text',
@@ -58,6 +67,10 @@ export async function recallHandler(graph, input) {
                     nodes: enriched.filter(Boolean),
                     totalCount: result.totalCount,
                     hasMore: result.hasMore,
+                    ...(vaultResults.length > 0 && {
+                        vault: vaultResults,
+                        vaultCount: vaultResults.length,
+                    }),
                 }),
             }],
     };

package/dist/tools/research.d.ts

@@ -1,5 +1,6 @@
 import { z } from 'zod';
 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"]>>;
@@ -52,7 +53,7 @@ export declare const researchSchema: z.ZodObject<{
     domainFilter?: string[] | undefined;
 }>;
 export type ResearchInput = z.infer<typeof researchSchema>;
-export declare function researchHandler(graph: ThinkingGraph, input: ResearchInput): Promise<{
+export declare function researchHandler(graph: ThinkingGraph, input: ResearchInput, vault?: VaultBridge, projectSlug?: string): Promise<{
     content: {
         type: "text";
         text: string;

package/dist/tools/research.js

@@ -118,7 +118,7 @@ function buildActionPlan(input) {
     }
     return steps;
 }
-export async function researchHandler(graph, input) {
+export async function researchHandler(graph, input, vault, projectSlug) {
     // ── Phase 2: ingest findings ──────────────────────────
     if (input.researchId && input.findings?.length) {
         const researchNode = await graph.getNode(input.researchId);
@@ -132,6 +132,7 @@ export async function researchHandler(graph, input) {
         }
         const session = await graph.getCurrentSession();
         const storedNodes = [];
+        const vaultPaths = [];
         for (const finding of input.findings) {
             // Check for duplicates
             const existing = await graph.findSimilar(finding.content, 'research', input.projectId);
@@ -158,6 +159,30 @@ export async function researchHandler(graph, input) {
                 reasoning: 'Finding from research query',
             });
             storedNodes.push(node.id);
+            // Write finding to Obsidian vault
+            if (vault && projectSlug) {
+                try {
+                    const title = finding.content.slice(0, 80).replace(/[^a-zA-Z0-9 ]/g, '').trim()
+                        || `Research ${input.intent}`;
+                    const vaultPath = vault.write({
+                        title,
+                        type: 'research',
+                        content: finding.content,
+                        projectSlug,
+                        metadata: {
+                            nodeId: node.id,
+                            researchQuery: researchNode.content,
+                            intent: input.intent,
+                            ...(finding.source && { source: finding.source }),
+                            ...(finding.confidence && { confidence: finding.confidence }),
+                        },
+                    });
+                    vaultPaths.push(vaultPath);
+                }
+                catch (err) {
+                    console.error('Vault write failed for research finding:', err);
+                }
+            }
         }
         return {
             content: [{
@@ -167,6 +192,7 @@ export async function researchHandler(graph, input) {
                         researchId: input.researchId,
                         storedCount: storedNodes.length,
                         nodeIds: storedNodes,
+                        ...(vaultPaths.length > 0 && { vaultPaths }),
                         suggestions: [
                             {
                                 tool: 'relate',

package/dist/vault/bridge.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Lightweight Obsidian vault bridge for thinking-graph.
+ *
+ * Reads and writes markdown files with YAML frontmatter to an Obsidian vault,
+ * scoped by project. Does NOT depend on the knowledge-graph package — it uses
+ * gray-matter and simple file I/O so the two MCP servers stay decoupled.
+ *
+ * knowledge-graph can later re-index the same vault for semantic search,
+ * community detection, and graph analytics.
+ */
+import type { NodeType } from '../engine/types.js';
+export interface VaultNote {
+    relPath: string;
+    title: string;
+    content: string;
+    frontmatter: Record<string, unknown>;
+}
+export interface VaultSearchResult {
+    relPath: string;
+    title: string;
+    excerpt: string;
+    score: number;
+    source: 'vault';
+}
+export interface VaultWriteOpts {
+    title: string;
+    type: NodeType;
+    content: string;
+    projectSlug: string;
+    metadata?: Record<string, unknown>;
+}
+export declare class VaultBridge {
+    private vaultRoot;
+    constructor(vaultPath: string);
+    get root(): string;
+    /** Resolve the directory for a given project + node type. */
+    private projectDir;
+    /**
+     * Write a note to the vault. Returns the relative path within the vault.
+     * If a file with the same title already exists, appends a timestamp suffix.
+     */
+    write(opts: VaultWriteOpts): string;
+    /** Read a single note by relative path. */
+    read(relPath: string): VaultNote | null;
+    /**
+     * Full-text search across the project's vault directory.
+     * Uses Jaccard token overlap for scoring (same algo as dedup).
+     */
+    search(query: string, projectSlug: string, opts?: {
+        limit?: number;
+        type?: string;
+    }): VaultSearchResult[];
+    /**
+     * List all notes for a project, optionally filtered by type.
+     */
+    list(projectSlug: string, type?: string): VaultNote[];
+}

package/dist/vault/bridge.js

@@ -0,0 +1,206 @@
+/**
+ * Lightweight Obsidian vault bridge for thinking-graph.
+ *
+ * Reads and writes markdown files with YAML frontmatter to an Obsidian vault,
+ * scoped by project. Does NOT depend on the knowledge-graph package — it uses
+ * gray-matter and simple file I/O so the two MCP servers stay decoupled.
+ *
+ * knowledge-graph can later re-index the same vault for semantic search,
+ * community detection, and graph analytics.
+ */
+import { existsSync, mkdirSync, readFileSync, writeFileSync, readdirSync, statSync } from 'fs';
+import { join, basename, relative, extname } from 'path';
+import { homedir } from 'os';
+import matter from 'gray-matter';
+import { tokenize } from '../engine/dedup.js';
+// ─── Directory mapping ────────────────────────────────
+const TYPE_DIRS = {
+    insight: 'Insights',
+    pattern: 'Patterns',
+    principle: 'Principles',
+    decision: 'Decisions',
+    code_fact: 'Code Facts',
+    tech_debt: 'Tech Debt',
+    research: 'Research',
+    thought: 'Thoughts',
+    assumption: 'Assumptions',
+    detection: 'Detections',
+    skill_result: 'Skill Results',
+};
+// ─── Helpers ──────────────────────────────────────────
+function expandHome(p) {
+    if (p.startsWith('~/'))
+        return join(homedir(), p.slice(2));
+    return p;
+}
+function sanitizeFilename(name) {
+    return name
+        .replace(/[<>:"/\\|?*]/g, '')
+        .replace(/\s+/g, ' ')
+        .trim()
+        .slice(0, 120);
+}
+/**
+ * Walk a directory tree and yield .md files.
+ */
+function* walkMd(dir) {
+    if (!existsSync(dir))
+        return;
+    for (const entry of readdirSync(dir)) {
+        if (entry.startsWith('.'))
+            continue;
+        const full = join(dir, entry);
+        const stat = statSync(full);
+        if (stat.isDirectory()) {
+            yield* walkMd(full);
+        }
+        else if (extname(entry) === '.md') {
+            yield full;
+        }
+    }
+}
+// ─── VaultBridge ──────────────────────────────────────
+export class VaultBridge {
+    vaultRoot;
+    constructor(vaultPath) {
+        this.vaultRoot = expandHome(vaultPath);
+    }
+    get root() {
+        return this.vaultRoot;
+    }
+    /** Resolve the directory for a given project + node type. */
+    projectDir(projectSlug, type) {
+        const base = join(this.vaultRoot, projectSlug);
+        if (!type)
+            return base;
+        const subdir = TYPE_DIRS[type] ?? type;
+        return join(base, subdir);
+    }
+    // ─── Write ──────────────────────────────────────────
+    /**
+     * Write a note to the vault. Returns the relative path within the vault.
+     * If a file with the same title already exists, appends a timestamp suffix.
+     */
+    write(opts) {
+        const dir = this.projectDir(opts.projectSlug, opts.type);
+        mkdirSync(dir, { recursive: true });
+        let filename = `${sanitizeFilename(opts.title)}.md`;
+        let absPath = join(dir, filename);
+        // Deduplicate filename
+        if (existsSync(absPath)) {
+            const ts = new Date().toISOString().replace(/[:.]/g, '-').slice(0, 19);
+            filename = `${sanitizeFilename(opts.title)} ${ts}.md`;
+            absPath = join(dir, filename);
+        }
+        const fm = {
+            title: opts.title,
+            type: opts.type,
+            project: opts.projectSlug,
+            created: new Date().toISOString(),
+            ...opts.metadata,
+        };
+        const fileContent = matter.stringify(opts.content, fm);
+        writeFileSync(absPath, fileContent, 'utf-8');
+        return relative(this.vaultRoot, absPath);
+    }
+    // ─── Read ───────────────────────────────────────────
+    /** Read a single note by relative path. */
+    read(relPath) {
+        const absPath = join(this.vaultRoot, relPath);
+        if (!existsSync(absPath))
+            return null;
+        const raw = readFileSync(absPath, 'utf-8');
+        const parsed = matter(raw);
+        return {
+            relPath,
+            title: parsed.data.title ?? basename(relPath, '.md'),
+            content: parsed.content,
+            frontmatter: parsed.data,
+        };
+    }
+    // ─── Search ─────────────────────────────────────────
+    /**
+     * Full-text search across the project's vault directory.
+     * Uses Jaccard token overlap for scoring (same algo as dedup).
+     */
+    search(query, projectSlug, opts) {
+        const dir = opts?.type
+            ? this.projectDir(projectSlug, opts.type)
+            : this.projectDir(projectSlug);
+        const queryTokens = new Set(tokenize(query));
+        if (queryTokens.size === 0)
+            return [];
+        const results = [];
+        const limit = opts?.limit ?? 20;
+        for (const absPath of walkMd(dir)) {
+            const raw = readFileSync(absPath, 'utf-8');
+            const parsed = matter(raw);
+            const text = parsed.content;
+            const title = parsed.data.title ?? basename(absPath, '.md');
+            // Score: Jaccard overlap on content tokens
+            const contentTokens = new Set(tokenize(text));
+            if (contentTokens.size === 0)
+                continue;
+            const intersection = [...queryTokens].filter(t => contentTokens.has(t)).length;
+            if (intersection === 0)
+                continue;
+            const union = new Set([...queryTokens, ...contentTokens]).size;
+            const score = intersection / union;
+            // Extract an excerpt around the first matching token
+            const excerpt = extractExcerpt(text, query);
+            results.push({
+                relPath: relative(this.vaultRoot, absPath),
+                title,
+                excerpt,
+                score,
+                source: 'vault',
+            });
+        }
+        // Sort by score descending, take top N
+        results.sort((a, b) => b.score - a.score);
+        return results.slice(0, limit);
+    }
+    /**
+     * List all notes for a project, optionally filtered by type.
+     */
+    list(projectSlug, type) {
+        const dir = type
+            ? this.projectDir(projectSlug, type)
+            : this.projectDir(projectSlug);
+        const notes = [];
+        for (const absPath of walkMd(dir)) {
+            const raw = readFileSync(absPath, 'utf-8');
+            const parsed = matter(raw);
+            notes.push({
+                relPath: relative(this.vaultRoot, absPath),
+                title: parsed.data.title ?? basename(absPath, '.md'),
+                content: parsed.content,
+                frontmatter: parsed.data,
+            });
+        }
+        return notes;
+    }
+}
+// ─── Utility ──────────────────────────────────────────
+function extractExcerpt(text, query, radius = 120) {
+    const lower = text.toLowerCase();
+    const words = query.toLowerCase().split(/\W+/).filter(Boolean);
+    let bestIdx = -1;
+    for (const w of words) {
+        const idx = lower.indexOf(w);
+        if (idx !== -1) {
+            bestIdx = idx;
+            break;
+        }
+    }
+    if (bestIdx === -1)
+        return text.slice(0, radius * 2);
+    const start = Math.max(0, bestIdx - radius);
+    const end = Math.min(text.length, bestIdx + radius);
+    let excerpt = text.slice(start, end).trim();
+    if (start > 0)
+        excerpt = '...' + excerpt;
+    if (end < text.length)
+        excerpt += '...';
+    return excerpt;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@feelingmindful/thinking-graph",
-  "version": "1.9.0",
+  "version": "1.10.0",
   "description": "Persistent graph-based MCP thinking server for the feeling-mindful plugin marketplace",
   "type": "module",
   "main": "dist/index.js",
@@ -31,6 +31,7 @@
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.12.0",
+    "gray-matter": "^4.0.3",
     "sql.js": "^1.12.0",
     "uuid": "^10.0.0",
     "zod": "^3.23.0"