@feelingmindful/thinking-graph 1.2.0

package/dist/compat/sequential.d.ts

@@ -0,0 +1,45 @@
+import { z } from 'zod';
+import type { ThinkingGraph } from '../engine/graph.js';
+/**
+ * Backward compatibility shim for the original `sequentialthinking` tool.
+ * Maps the old API (thought, thoughtNumber, totalThoughts, nextThoughtNeeded)
+ * to the new `think` tool, preserving the original response format.
+ */
+export declare const sequentialSchema: z.ZodObject<{
+    thought: z.ZodString;
+    thoughtNumber: z.ZodNumber;
+    totalThoughts: z.ZodNumber;
+    nextThoughtNeeded: z.ZodBoolean;
+    isRevision: z.ZodOptional<z.ZodBoolean>;
+    revisesThought: z.ZodOptional<z.ZodNumber>;
+    branchFromThought: z.ZodOptional<z.ZodNumber>;
+    branchId: z.ZodOptional<z.ZodString>;
+    needsMoreThoughts: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    thought: string;
+    thoughtNumber: number;
+    totalThoughts: number;
+    nextThoughtNeeded: boolean;
+    branchId?: string | undefined;
+    isRevision?: boolean | undefined;
+    revisesThought?: number | undefined;
+    branchFromThought?: number | undefined;
+    needsMoreThoughts?: boolean | undefined;
+}, {
+    thought: string;
+    thoughtNumber: number;
+    totalThoughts: number;
+    nextThoughtNeeded: boolean;
+    branchId?: string | undefined;
+    isRevision?: boolean | undefined;
+    revisesThought?: number | undefined;
+    branchFromThought?: number | undefined;
+    needsMoreThoughts?: boolean | undefined;
+}>;
+export type SequentialInput = z.infer<typeof sequentialSchema>;
+export declare function compatHandler(graph: ThinkingGraph, input: SequentialInput): Promise<{
+    content: {
+        type: "text";
+        text: string;
+    }[];
+}>;

package/dist/compat/sequential.js

@@ -0,0 +1,46 @@
+import { z } from 'zod';
+/**
+ * Backward compatibility shim for the original `sequentialthinking` tool.
+ * Maps the old API (thought, thoughtNumber, totalThoughts, nextThoughtNeeded)
+ * to the new `think` tool, preserving the original response format.
+ */
+export const sequentialSchema = z.object({
+    thought: z.string().describe('The current thinking step'),
+    thoughtNumber: z.number().int().min(1).describe('Current thought number'),
+    totalThoughts: z.number().int().min(1).describe('Estimated total thoughts'),
+    nextThoughtNeeded: z.boolean().describe('Whether another step is needed'),
+    isRevision: z.boolean().optional(),
+    revisesThought: z.number().int().min(1).optional(),
+    branchFromThought: z.number().int().min(1).optional(),
+    branchId: z.string().optional(),
+    needsMoreThoughts: z.boolean().optional(),
+});
+export async function compatHandler(graph, input) {
+    const session = await graph.getCurrentSession();
+    const node = await graph.addNode({
+        type: 'thought',
+        content: input.thought,
+        sessionId: session.id,
+        metadata: {},
+        thoughtNumber: input.thoughtNumber,
+        totalThoughts: input.totalThoughts,
+        branchId: input.branchId,
+        isRevision: input.isRevision,
+        revisesThought: input.revisesThought,
+    });
+    await graph.touchSession(session.id);
+    const stats = await graph.storage.getStats();
+    // Return exactly the same format as the original server
+    return {
+        content: [{
+                type: 'text',
+                text: JSON.stringify({
+                    thoughtNumber: node.thoughtNumber,
+                    totalThoughts: node.totalThoughts,
+                    nextThoughtNeeded: input.nextThoughtNeeded,
+                    branches: [],
+                    thoughtHistoryLength: stats.totalNodes,
+                }),
+            }],
+    };
+}

package/dist/engine/dedup.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Content deduplication using Jaccard similarity on word tokens.
+ */
+export declare function tokenize(content: string): string[];
+export declare function similarity(a: string, b: string): number;

package/dist/engine/dedup.js

@@ -0,0 +1,17 @@
+/**
+ * Content deduplication using Jaccard similarity on word tokens.
+ */
+export function tokenize(content) {
+    return content.toLowerCase().split(/\W+/).filter(Boolean);
+}
+export function similarity(a, b) {
+    const tokensA = new Set(tokenize(a));
+    const tokensB = new Set(tokenize(b));
+    if (tokensA.size === 0 && tokensB.size === 0)
+        return 1.0;
+    if (tokensA.size === 0 || tokensB.size === 0)
+        return 0.0;
+    const intersection = [...tokensA].filter(t => tokensB.has(t)).length;
+    const union = new Set([...tokensA, ...tokensB]).size;
+    return intersection / union;
+}

package/dist/engine/graph.d.ts

@@ -0,0 +1,49 @@
+import type { StorageAdapter } from '../storage/adapter.js';
+import type { Node, Edge, Session, NodeType, EdgeType, NodeQuery, PaginatedResult, NodeWithEdges, ExportOpts, GraphExport, HealthReport, SkillRegistryEntry } from './types.js';
+export declare class ThinkingGraph {
+    storage: StorageAdapter;
+    private currentSessionId;
+    constructor(storage: StorageAdapter);
+    addNode(input: Omit<Node, 'id' | 'createdAt' | 'updatedAt'> & {
+        id?: string;
+    }): Promise<Node>;
+    getNode(id: string): Promise<Node | null>;
+    findNodes(query: NodeQuery): Promise<PaginatedResult<Node>>;
+    searchNodes(text: string, limit?: number): Promise<Node[]>;
+    findSimilar(content: string, type: NodeType, projectId?: string, threshold?: number): Promise<Node | null>;
+    addEdge(input: Omit<Edge, 'id' | 'createdAt' | 'weight'> & {
+        id?: string;
+        weight?: number;
+    }): Promise<Edge & {
+        created: boolean;
+    }>;
+    getEdges(nodeId: string, direction?: 'outgoing' | 'incoming' | 'both', type?: EdgeType): Promise<Edge[]>;
+    traverse(startId: string, edgeType: EdgeType, depth?: number): Promise<Node[]>;
+    findContradictions(sessionId?: string): Promise<{
+        a: Node;
+        b: Node;
+        reasoning?: string;
+    }[]>;
+    findViolations(projectId?: string): Promise<{
+        node: Node;
+        principle: Node;
+    }[]>;
+    getNodeWithEdges(nodeId: string): Promise<NodeWithEdges | null>;
+    createSession(opts?: Partial<Session>): Promise<Session>;
+    getCurrentSession(): Promise<Session>;
+    touchSession(id: string): Promise<void>;
+    getSkillForDebt(debtNode: Node): Promise<SkillRegistryEntry | null>;
+    getSkillsForArea(area: string, platform?: string): Promise<SkillRegistryEntry[]>;
+    getProjectHealth(projectId: string): Promise<HealthReport>;
+    getTechDebtSummary(projectId: string): Promise<{
+        total: number;
+        bySeverity: Record<string, number>;
+    }>;
+    getDecisionLog(projectId?: string): Promise<Node[]>;
+    exportGraph(opts?: ExportOpts): Promise<GraphExport>;
+    exportSummary(opts?: ExportOpts): Promise<string>;
+    seed(): Promise<{
+        principles: number;
+        skills: number;
+    }>;
+}

package/dist/engine/graph.js

@@ -0,0 +1,250 @@
+import { v4 as uuid } from 'uuid';
+import { similarity } from './dedup.js';
+import { seedAll } from './seed.js';
+export class ThinkingGraph {
+    storage;
+    currentSessionId = null;
+    constructor(storage) {
+        this.storage = storage;
+    }
+    // ─── Node operations ─────────────────────────────────
+    async addNode(input) {
+        const now = new Date().toISOString();
+        const node = {
+            id: input.id ?? uuid(),
+            type: input.type,
+            content: input.content,
+            sessionId: input.sessionId,
+            projectId: input.projectId,
+            metadata: input.metadata ?? {},
+            createdAt: now,
+            updatedAt: now,
+            thoughtNumber: input.thoughtNumber,
+            totalThoughts: input.totalThoughts,
+            branchId: input.branchId,
+            isRevision: input.isRevision,
+            revisesThought: input.revisesThought,
+        };
+        // Auto-adjust totalThoughts if thoughtNumber exceeds it
+        if (node.thoughtNumber && node.totalThoughts && node.thoughtNumber > node.totalThoughts) {
+            node.totalThoughts = node.thoughtNumber;
+        }
+        await this.storage.insertNode(node);
+        return node;
+    }
+    async getNode(id) {
+        return this.storage.getNode(id);
+    }
+    async findNodes(query) {
+        return this.storage.queryNodes(query);
+    }
+    async searchNodes(text, limit = 20) {
+        return this.storage.searchContent(text, limit);
+    }
+    async findSimilar(content, type, projectId, threshold = 0.9) {
+        // Get candidates of the same type
+        const candidates = await this.storage.queryNodes({
+            type,
+            projectId,
+            limit: 100,
+        });
+        for (const node of candidates.items) {
+            if (similarity(content, node.content) >= threshold) {
+                return node;
+            }
+        }
+        return null;
+    }
+    // ─── Edge operations ─────────────────────────────────
+    async addEdge(input) {
+        const edge = {
+            id: input.id ?? uuid(),
+            sourceId: input.sourceId,
+            targetId: input.targetId,
+            type: input.type,
+            weight: input.weight ?? 1.0,
+            reasoning: input.reasoning,
+            createdAt: new Date().toISOString(),
+        };
+        const created = await this.storage.insertEdge(edge);
+        return { ...edge, created };
+    }
+    async getEdges(nodeId, direction = 'both', type) {
+        const results = [];
+        if (direction === 'outgoing' || direction === 'both') {
+            results.push(...await this.storage.getEdgesFrom(nodeId, type));
+        }
+        if (direction === 'incoming' || direction === 'both') {
+            results.push(...await this.storage.getEdgesTo(nodeId, type));
+        }
+        return results;
+    }
+    async traverse(startId, edgeType, depth = 1) {
+        return this.storage.traverseEdges(startId, edgeType, depth);
+    }
+    async findContradictions(sessionId) {
+        const query = sessionId ? { sessionId } : {};
+        const allNodes = await this.storage.queryNodes({ ...query, limit: 1000 });
+        const results = [];
+        for (const node of allNodes.items) {
+            const edges = await this.storage.getEdgesFrom(node.id, 'contradicts');
+            for (const edge of edges) {
+                const target = await this.storage.getNode(edge.targetId);
+                if (target) {
+                    results.push({ a: node, b: target, reasoning: edge.reasoning });
+                }
+            }
+        }
+        return results;
+    }
+    async findViolations(projectId) {
+        const query = projectId ? { projectId } : {};
+        const allNodes = await this.storage.queryNodes({ ...query, limit: 1000 });
+        const results = [];
+        for (const node of allNodes.items) {
+            const edges = await this.storage.getEdgesFrom(node.id, 'violates');
+            for (const edge of edges) {
+                const principle = await this.storage.getNode(edge.targetId);
+                if (principle && principle.type === 'principle') {
+                    results.push({ node, principle });
+                }
+            }
+        }
+        return results;
+    }
+    // ─── Node with edges (for recall responses) ──────────
+    async getNodeWithEdges(nodeId) {
+        const node = await this.storage.getNode(nodeId);
+        if (!node)
+            return null;
+        const outgoing = await this.storage.getEdgesFrom(nodeId);
+        const incoming = await this.storage.getEdgesTo(nodeId);
+        const edges = [];
+        for (const e of outgoing) {
+            const target = await this.storage.getNode(e.targetId);
+            edges.push({
+                type: e.type,
+                direction: 'outgoing',
+                targetId: e.targetId,
+                targetContent: target?.content.slice(0, 100) ?? '',
+            });
+        }
+        for (const e of incoming) {
+            const source = await this.storage.getNode(e.sourceId);
+            edges.push({
+                type: e.type,
+                direction: 'incoming',
+                targetId: e.sourceId,
+                targetContent: source?.content.slice(0, 100) ?? '',
+            });
+        }
+        return { ...node, edges };
+    }
+    // ─── Session operations ──────────────────────────────
+    async createSession(opts) {
+        const now = new Date().toISOString();
+        const session = {
+            id: opts?.id ?? uuid(),
+            projectId: opts?.projectId,
+            projectPath: opts?.projectPath,
+            description: opts?.description,
+            startedAt: now,
+            lastActiveAt: now,
+        };
+        await this.storage.insertSession(session);
+        this.currentSessionId = session.id;
+        return session;
+    }
+    async getCurrentSession() {
+        if (this.currentSessionId) {
+            const session = await this.storage.getSession(this.currentSessionId);
+            if (session)
+                return session;
+        }
+        // Create a new session
+        return this.createSession();
+    }
+    async touchSession(id) {
+        await this.storage.updateSession(id, { lastActiveAt: new Date().toISOString() });
+    }
+    // ─── Skill registry ──────────────────────────────────
+    async getSkillForDebt(debtNode) {
+        // Look at the debt's metadata for area, then find a skill that addresses that area
+        const area = debtNode.metadata?.area;
+        if (!area)
+            return null;
+        const skills = await this.storage.querySkills({});
+        for (const skill of skills) {
+            if (skill.areas.includes(area) && skill.detects?.includes('needs-work')) {
+                return skill;
+            }
+        }
+        return null;
+    }
+    async getSkillsForArea(area, platform) {
+        const allSkills = await this.storage.querySkills(platform ? { platform } : {});
+        return allSkills.filter(s => s.areas.includes(area));
+    }
+    // ─── Analysis ─────────────────────────────────────────
+    async getProjectHealth(projectId) {
+        const stats = await this.storage.getStats();
+        const debtResult = await this.storage.queryNodes({ type: 'tech_debt', projectId, limit: 10 });
+        const violations = await this.findViolations(projectId);
+        const decisions = await this.storage.queryNodes({ type: 'decision', projectId, limit: 10 });
+        const recent = await this.storage.queryNodes({ projectId, limit: 10 });
+        return {
+            projectId,
+            stats,
+            topDebt: debtResult.items,
+            violations,
+            openDecisions: decisions.items,
+            recentActivity: recent.items,
+        };
+    }
+    async getTechDebtSummary(projectId) {
+        const result = await this.storage.queryNodes({ type: 'tech_debt', projectId, limit: 1000 });
+        const bySeverity = {};
+        for (const node of result.items) {
+            const sev = node.metadata?.severity ?? 'unknown';
+            bySeverity[sev] = (bySeverity[sev] ?? 0) + 1;
+        }
+        return { total: result.totalCount, bySeverity };
+    }
+    async getDecisionLog(projectId) {
+        const result = await this.storage.queryNodes({ type: 'decision', projectId, limit: 100 });
+        return result.items;
+    }
+    // ─── Export ───────────────────────────────────────────
+    async exportGraph(opts) {
+        return this.storage.exportAll(opts);
+    }
+    async exportSummary(opts) {
+        const stats = await this.storage.getStats();
+        const lines = [
+            '# Thinking Graph Summary',
+            '',
+            `**Nodes:** ${stats.totalNodes}`,
+            `**Edges:** ${stats.totalEdges}`,
+            '',
+            '## Nodes by Type',
+        ];
+        for (const [type, count] of Object.entries(stats.nodesByType).sort((a, b) => b[1] - a[1])) {
+            lines.push(`- ${type}: ${count}`);
+        }
+        lines.push('', '## Edges by Type');
+        for (const [type, count] of Object.entries(stats.edgesByType).sort((a, b) => b[1] - a[1])) {
+            lines.push(`- ${type}: ${count}`);
+        }
+        if (stats.techDebtCount > 0) {
+            lines.push('', `## Tech Debt: ${stats.techDebtCount} items`);
+        }
+        if (stats.principleViolations > 0) {
+            lines.push(`## Principle Violations: ${stats.principleViolations}`);
+        }
+        return lines.join('\n');
+    }
+    // ─── Seeding ──────────────────────────────────────────
+    async seed() {
+        return seedAll(this.storage);
+    }
+}

package/dist/engine/seed.d.ts

@@ -0,0 +1,7 @@
+import type { StorageAdapter } from '../storage/adapter.js';
+export declare function seedPrinciples(storage: StorageAdapter): Promise<number>;
+export declare function seedSkillRegistry(storage: StorageAdapter): Promise<number>;
+export declare function seedAll(storage: StorageAdapter): Promise<{
+    principles: number;
+    skills: number;
+}>;

package/dist/engine/seed.js

@@ -0,0 +1,43 @@
+import { readFileSync } from 'fs';
+import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const SEEDS_DIR = join(__dirname, '../../seeds');
+export async function seedPrinciples(storage) {
+    const raw = JSON.parse(readFileSync(join(SEEDS_DIR, 'principles.json'), 'utf-8'));
+    const now = new Date().toISOString();
+    let count = 0;
+    for (const p of raw) {
+        const existing = await storage.getNode(p.id);
+        if (!existing) {
+            await storage.insertNode({
+                id: p.id,
+                type: p.type,
+                content: p.content,
+                sessionId: 'seed',
+                metadata: p.metadata ?? {},
+                createdAt: now,
+                updatedAt: now,
+            });
+            count++;
+        }
+    }
+    return count;
+}
+export async function seedSkillRegistry(storage) {
+    const skills = JSON.parse(readFileSync(join(SEEDS_DIR, 'skill-registry.json'), 'utf-8'));
+    let count = 0;
+    for (const s of skills) {
+        const existing = await storage.querySkills({ id: s.id });
+        if (existing.length === 0) {
+            await storage.insertSkill(s);
+            count++;
+        }
+    }
+    return count;
+}
+export async function seedAll(storage) {
+    const principles = await seedPrinciples(storage);
+    const skills = await seedSkillRegistry(storage);
+    return { principles, skills };
+}

package/dist/engine/types.d.ts

@@ -0,0 +1,114 @@
+export declare const NODE_TYPES: readonly ["thought", "decision", "insight", "code_fact", "assumption", "detection", "tech_debt", "principle", "pattern", "skill_result", "research"];
+export type NodeType = (typeof NODE_TYPES)[number];
+export declare function isNodeType(v: string): v is NodeType;
+export declare const EDGE_TYPES: readonly ["depends_on", "contradicts", "supports", "refines", "supersedes", "similar_to", "located_in", "violates", "addresses", "detected_by", "invoked_by"];
+export type EdgeType = (typeof EDGE_TYPES)[number];
+export declare function isEdgeType(v: string): v is EdgeType;
+export declare const GLOBAL_NODE_TYPES: NodeType[];
+export interface Node {
+    id: string;
+    type: NodeType;
+    content: string;
+    sessionId: string;
+    projectId?: string;
+    metadata: Record<string, unknown>;
+    createdAt: string;
+    updatedAt: string;
+    thoughtNumber?: number;
+    totalThoughts?: number;
+    branchId?: string;
+    isRevision?: boolean;
+    revisesThought?: number;
+}
+export interface Edge {
+    id: string;
+    sourceId: string;
+    targetId: string;
+    type: EdgeType;
+    weight: number;
+    reasoning?: string;
+    createdAt: string;
+}
+export interface Session {
+    id: string;
+    projectId?: string;
+    projectPath?: string;
+    description?: string;
+    startedAt: string;
+    lastActiveAt: string;
+}
+export interface SkillRegistryEntry {
+    id: string;
+    pluginName: string;
+    skillName: string;
+    verb?: string;
+    invocation: string;
+    areas: string[];
+    detects: string[];
+    produces: string[];
+    invokes: string[];
+    platform?: string;
+}
+export interface NodeQuery {
+    query?: string;
+    type?: NodeType | NodeType[];
+    sessionId?: string;
+    projectId?: string;
+    crossProject?: boolean;
+    relatedTo?: string;
+    edgeType?: EdgeType | EdgeType[];
+    direction?: 'outgoing' | 'incoming' | 'both';
+    depth?: number;
+    since?: string;
+    metadata?: Record<string, unknown>;
+    limit?: number;
+    offset?: number;
+}
+export interface PaginatedResult<T> {
+    items: T[];
+    totalCount: number;
+    hasMore: boolean;
+}
+export interface NodeWithEdges extends Node {
+    edges: {
+        type: EdgeType;
+        direction: 'outgoing' | 'incoming';
+        targetId: string;
+        targetContent: string;
+    }[];
+}
+export interface ExportOpts {
+    format: 'json' | 'summary';
+    sessionId?: string;
+    projectId?: string;
+    type?: NodeType | NodeType[];
+    includeEdges?: boolean;
+    outputPath?: string;
+}
+export interface GraphExport {
+    exportedAt: string;
+    nodeCount: number;
+    edgeCount: number;
+    sessions: Session[];
+    nodes: Node[];
+    edges: Edge[];
+}
+export interface GraphStats {
+    totalNodes: number;
+    totalEdges: number;
+    nodesByType: Record<string, number>;
+    edgesByType: Record<string, number>;
+    techDebtCount: number;
+    principleViolations: number;
+}
+export interface HealthReport {
+    projectId: string;
+    stats: GraphStats;
+    topDebt: Node[];
+    violations: {
+        node: Node;
+        principle: Node;
+    }[];
+    openDecisions: Node[];
+    recentActivity: Node[];
+}

package/dist/engine/types.js

@@ -0,0 +1,18 @@
+export const NODE_TYPES = [
+    'thought', 'decision', 'insight', 'code_fact', 'assumption',
+    'detection', 'tech_debt', 'principle', 'pattern',
+    'skill_result', 'research',
+];
+export function isNodeType(v) {
+    return NODE_TYPES.includes(v);
+}
+export const EDGE_TYPES = [
+    'depends_on', 'contradicts', 'supports', 'refines',
+    'supersedes', 'similar_to', 'located_in', 'violates',
+    'addresses', 'detected_by', 'invoked_by',
+];
+export function isEdgeType(v) {
+    return EDGE_TYPES.includes(v);
+}
+// Node types that go to the global DB (cross-project)
+export const GLOBAL_NODE_TYPES = ['insight', 'principle', 'pattern'];

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/index.js

@@ -0,0 +1,52 @@
+#!/usr/bin/env node
+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 { InMemoryAdapter } from './storage/memory.js';
+import { thinkSchema, thinkHandler } from './tools/think.js';
+import { relateSchema, relateHandler } from './tools/relate.js';
+import { recallSchema, recallHandler } from './tools/recall.js';
+import { learnSchema, learnHandler } from './tools/learn.js';
+import { exportSchema, exportHandler } from './tools/export.js';
+import { sequentialSchema, compatHandler } from './compat/sequential.js';
+// ─── 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',
+    });
+// ─── Graph engine ────────────────────────────────────────
+const graph = new ThinkingGraph(storage);
+// ─── MCP Server ──────────────────────────────────────────
+const server = new McpServer({
+    name: 'thinking-graph',
+    version: '1.0.0',
+});
+// 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('export', 'Export the thinking graph as JSON or a human-readable markdown summary.', exportSchema.shape, async (input) => exportHandler(graph, input));
+// Backward compat: register the original tool name
+server.tool('sequentialthinking', 'Record a sequential thinking step (backward compatible with @modelcontextprotocol/server-sequential-thinking).', sequentialSchema.shape, async (input) => compatHandler(graph, input));
+// ─── Startup ─────────────────────────────────────────────
+async function main() {
+    await storage.initialize();
+    await graph.seed();
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    if (!process.env.DISABLE_THOUGHT_LOGGING) {
+        console.error('thinking-graph MCP server started');
+        console.error(`  Storage: ${memoryOnly ? 'in-memory' : 'SQLite'}`);
+        if (!memoryOnly) {
+            console.error(`  DB: ${process.env.THINKING_GRAPH_PROJECT_DB || '.premium/thinking.db'}`);
+        }
+    }
+}
+main().catch((err) => {
+    console.error('Failed to start thinking-graph:', err);
+    process.exit(1);
+});

package/dist/storage/adapter.d.ts

@@ -0,0 +1,20 @@
+import type { Node, Edge, Session, SkillRegistryEntry, NodeQuery, PaginatedResult, EdgeType, ExportOpts, GraphExport, GraphStats } from '../engine/types.js';
+export interface StorageAdapter {
+    initialize(): Promise<void>;
+    close(): Promise<void>;
+    insertNode(node: Node): Promise<void>;
+    getNode(id: string): Promise<Node | null>;
+    queryNodes(query: NodeQuery): Promise<PaginatedResult<Node>>;
+    searchContent(text: string, limit?: number): Promise<Node[]>;
+    insertEdge(edge: Edge): Promise<boolean>;
+    getEdgesFrom(nodeId: string, type?: EdgeType): Promise<Edge[]>;
+    getEdgesTo(nodeId: string, type?: EdgeType): Promise<Edge[]>;
+    traverseEdges(startId: string, type: EdgeType, maxDepth: number): Promise<Node[]>;
+    insertSession(session: Session): Promise<void>;
+    getSession(id: string): Promise<Session | null>;
+    updateSession(id: string, fields: Partial<Session>): Promise<void>;
+    insertSkill(entry: SkillRegistryEntry): Promise<void>;
+    querySkills(filter: Partial<SkillRegistryEntry>): Promise<SkillRegistryEntry[]>;
+    exportAll(opts?: ExportOpts): Promise<GraphExport>;
+    getStats(): Promise<GraphStats>;
+}