@feelingmindful/thinking-graph 1.2.0

package/dist/tools/learn.d.ts

@@ -0,0 +1,66 @@
+import { z } from 'zod';
+import type { ThinkingGraph } from '../engine/graph.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"]>;
+    projectId: z.ZodOptional<z.ZodString>;
+    filePath: z.ZodOptional<z.ZodString>;
+    lineRange: z.ZodOptional<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>;
+    severity: z.ZodOptional<z.ZodEnum<["critical", "high", "medium", "low"]>>;
+    effort: z.ZodOptional<z.ZodString>;
+    impact: z.ZodOptional<z.ZodString>;
+    relates: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        type: z.ZodEnum<["depends_on", "contradicts", "supports", "refines", "supersedes", "similar_to", "located_in", "violates", "addresses", "detected_by", "invoked_by"]>;
+        targetId: z.ZodString;
+        reasoning: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        type: "depends_on" | "contradicts" | "supports" | "refines" | "supersedes" | "similar_to" | "located_in" | "violates" | "addresses" | "detected_by" | "invoked_by";
+        targetId: string;
+        reasoning?: string | undefined;
+    }, {
+        type: "depends_on" | "contradicts" | "supports" | "refines" | "supersedes" | "similar_to" | "located_in" | "violates" | "addresses" | "detected_by" | "invoked_by";
+        targetId: string;
+        reasoning?: string | undefined;
+    }>, "many">>;
+    violatedBy: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, "strip", z.ZodTypeAny, {
+    type: "thought" | "decision" | "insight" | "code_fact" | "assumption" | "detection" | "tech_debt" | "principle" | "pattern" | "skill_result" | "research";
+    content: string;
+    projectId?: string | undefined;
+    metadata?: Record<string, unknown> | undefined;
+    severity?: "critical" | "high" | "medium" | "low" | undefined;
+    relates?: {
+        type: "depends_on" | "contradicts" | "supports" | "refines" | "supersedes" | "similar_to" | "located_in" | "violates" | "addresses" | "detected_by" | "invoked_by";
+        targetId: string;
+        reasoning?: string | undefined;
+    }[] | undefined;
+    filePath?: string | undefined;
+    lineRange?: [number, number] | undefined;
+    effort?: string | undefined;
+    impact?: string | undefined;
+    violatedBy?: string[] | undefined;
+}, {
+    type: "thought" | "decision" | "insight" | "code_fact" | "assumption" | "detection" | "tech_debt" | "principle" | "pattern" | "skill_result" | "research";
+    content: string;
+    projectId?: string | undefined;
+    metadata?: Record<string, unknown> | undefined;
+    severity?: "critical" | "high" | "medium" | "low" | undefined;
+    relates?: {
+        type: "depends_on" | "contradicts" | "supports" | "refines" | "supersedes" | "similar_to" | "located_in" | "violates" | "addresses" | "detected_by" | "invoked_by";
+        targetId: string;
+        reasoning?: string | undefined;
+    }[] | undefined;
+    filePath?: string | undefined;
+    lineRange?: [number, number] | undefined;
+    effort?: string | undefined;
+    impact?: string | undefined;
+    violatedBy?: string[] | undefined;
+}>;
+export type LearnInput = z.infer<typeof learnSchema>;
+export declare function learnHandler(graph: ThinkingGraph, input: LearnInput): Promise<{
+    content: {
+        type: "text";
+        text: string;
+    }[];
+}>;

package/dist/tools/learn.js

@@ -0,0 +1,91 @@
+import { z } from 'zod';
+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'),
+    projectId: z.string().optional(),
+    filePath: z.string().optional().describe('For code_facts'),
+    lineRange: z.tuple([z.number(), z.number()]).optional().describe('Line range [start, end]'),
+    severity: z.enum(['critical', 'high', 'medium', 'low']).optional().describe('For tech_debt'),
+    effort: z.string().optional().describe('Estimated fix effort'),
+    impact: z.string().optional().describe('What breaks if unfixed'),
+    relates: z.array(z.object({
+        type: z.enum(EDGE_TYPES),
+        targetId: z.string(),
+        reasoning: z.string().optional(),
+    })).optional(),
+    violatedBy: z.array(z.string()).optional().describe('Node IDs violating this'),
+    metadata: z.record(z.unknown()).optional(),
+});
+export async function learnHandler(graph, input) {
+    // Check for duplicate
+    const existing = await graph.findSimilar(input.content, input.type, input.projectId);
+    if (existing) {
+        return {
+            content: [{
+                    type: 'text',
+                    text: JSON.stringify({
+                        nodeId: existing.id,
+                        type: existing.type,
+                        relatedCount: 0,
+                        duplicateOf: existing.id,
+                    }),
+                }],
+        };
+    }
+    // Build metadata from structured fields
+    const metadata = { ...input.metadata };
+    if (input.filePath)
+        metadata.filePath = input.filePath;
+    if (input.lineRange)
+        metadata.lineRange = input.lineRange;
+    if (input.severity)
+        metadata.severity = input.severity;
+    if (input.effort)
+        metadata.effort = input.effort;
+    if (input.impact)
+        metadata.impact = input.impact;
+    const session = await graph.getCurrentSession();
+    const node = await graph.addNode({
+        type: input.type,
+        content: input.content,
+        sessionId: session.id,
+        projectId: input.projectId,
+        metadata,
+    });
+    // Create relationships
+    let relatedCount = 0;
+    if (input.relates) {
+        for (const rel of input.relates) {
+            await graph.addEdge({
+                sourceId: node.id,
+                targetId: rel.targetId,
+                type: rel.type,
+                reasoning: rel.reasoning,
+            });
+            relatedCount++;
+        }
+    }
+    // Create violation edges
+    if (input.violatedBy) {
+        for (const violatorId of input.violatedBy) {
+            await graph.addEdge({
+                sourceId: violatorId,
+                targetId: node.id,
+                type: 'violates',
+            });
+            relatedCount++;
+        }
+    }
+    return {
+        content: [{
+                type: 'text',
+                text: JSON.stringify({
+                    nodeId: node.id,
+                    type: node.type,
+                    relatedCount,
+                    duplicateOf: null,
+                }),
+            }],
+    };
+}

package/dist/tools/recall.d.ts

@@ -0,0 +1,52 @@
+import { z } from 'zod';
+import type { ThinkingGraph } from '../engine/graph.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">]>>;
+    sessionId: z.ZodOptional<z.ZodString>;
+    projectId: z.ZodOptional<z.ZodString>;
+    crossProject: z.ZodOptional<z.ZodBoolean>;
+    relatedTo: z.ZodOptional<z.ZodString>;
+    edgeType: z.ZodOptional<z.ZodUnion<[z.ZodEnum<["depends_on", "contradicts", "supports", "refines", "supersedes", "similar_to", "located_in", "violates", "addresses", "detected_by", "invoked_by"]>, z.ZodArray<z.ZodEnum<["depends_on", "contradicts", "supports", "refines", "supersedes", "similar_to", "located_in", "violates", "addresses", "detected_by", "invoked_by"]>, "many">]>>;
+    direction: z.ZodOptional<z.ZodEnum<["outgoing", "incoming", "both"]>>;
+    depth: z.ZodOptional<z.ZodNumber>;
+    since: z.ZodOptional<z.ZodString>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    limit: z.ZodOptional<z.ZodNumber>;
+    offset: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    type?: "thought" | "decision" | "insight" | "code_fact" | "assumption" | "detection" | "tech_debt" | "principle" | "pattern" | "skill_result" | "research" | ("thought" | "decision" | "insight" | "code_fact" | "assumption" | "detection" | "tech_debt" | "principle" | "pattern" | "skill_result" | "research")[] | undefined;
+    sessionId?: string | undefined;
+    projectId?: string | undefined;
+    metadata?: Record<string, unknown> | undefined;
+    query?: string | undefined;
+    crossProject?: boolean | undefined;
+    relatedTo?: string | undefined;
+    edgeType?: "depends_on" | "contradicts" | "supports" | "refines" | "supersedes" | "similar_to" | "located_in" | "violates" | "addresses" | "detected_by" | "invoked_by" | ("depends_on" | "contradicts" | "supports" | "refines" | "supersedes" | "similar_to" | "located_in" | "violates" | "addresses" | "detected_by" | "invoked_by")[] | undefined;
+    direction?: "outgoing" | "incoming" | "both" | undefined;
+    depth?: number | undefined;
+    since?: string | undefined;
+    limit?: number | undefined;
+    offset?: number | undefined;
+}, {
+    type?: "thought" | "decision" | "insight" | "code_fact" | "assumption" | "detection" | "tech_debt" | "principle" | "pattern" | "skill_result" | "research" | ("thought" | "decision" | "insight" | "code_fact" | "assumption" | "detection" | "tech_debt" | "principle" | "pattern" | "skill_result" | "research")[] | undefined;
+    sessionId?: string | undefined;
+    projectId?: string | undefined;
+    metadata?: Record<string, unknown> | undefined;
+    query?: string | undefined;
+    crossProject?: boolean | undefined;
+    relatedTo?: string | undefined;
+    edgeType?: "depends_on" | "contradicts" | "supports" | "refines" | "supersedes" | "similar_to" | "located_in" | "violates" | "addresses" | "detected_by" | "invoked_by" | ("depends_on" | "contradicts" | "supports" | "refines" | "supersedes" | "similar_to" | "located_in" | "violates" | "addresses" | "detected_by" | "invoked_by")[] | undefined;
+    direction?: "outgoing" | "incoming" | "both" | undefined;
+    depth?: number | undefined;
+    since?: string | undefined;
+    limit?: number | undefined;
+    offset?: number | undefined;
+}>;
+export type RecallInput = z.infer<typeof recallSchema>;
+export declare function recallHandler(graph: ThinkingGraph, input: RecallInput): Promise<{
+    content: {
+        type: "text";
+        text: string;
+    }[];
+}>;

package/dist/tools/recall.js

@@ -0,0 +1,63 @@
+import { z } from 'zod';
+import { NODE_TYPES, EDGE_TYPES } from '../engine/types.js';
+export const recallSchema = z.object({
+    query: z.string().optional().describe('Full-text search'),
+    type: z.union([z.enum(NODE_TYPES), z.array(z.enum(NODE_TYPES))]).optional(),
+    sessionId: z.string().optional(),
+    projectId: z.string().optional(),
+    crossProject: z.boolean().optional().describe('Search across all projects'),
+    relatedTo: z.string().optional().describe('Find nodes connected to this ID'),
+    edgeType: z.union([z.enum(EDGE_TYPES), z.array(z.enum(EDGE_TYPES))]).optional(),
+    direction: z.enum(['outgoing', 'incoming', 'both']).optional(),
+    depth: z.number().int().min(1).optional().describe('Traversal depth'),
+    since: z.string().optional().describe('ISO timestamp'),
+    metadata: z.record(z.unknown()).optional(),
+    limit: z.number().int().min(1).max(100).optional(),
+    offset: z.number().int().min(0).optional(),
+});
+export async function recallHandler(graph, input) {
+    // If relatedTo is specified, use graph traversal
+    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: [{
+                    type: 'text',
+                    text: JSON.stringify({
+                        nodes: enriched.filter(Boolean),
+                        totalCount: nodes.length,
+                        hasMore: nodes.length > (input.limit ?? 20),
+                    }),
+                }],
+        };
+    }
+    // Standard query
+    const result = await graph.findNodes({
+        query: input.query,
+        type: input.type,
+        sessionId: input.sessionId,
+        projectId: input.projectId,
+        crossProject: input.crossProject,
+        since: input.since,
+        metadata: input.metadata,
+        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)));
+    return {
+        content: [{
+                type: 'text',
+                text: JSON.stringify({
+                    nodes: enriched.filter(Boolean),
+                    totalCount: result.totalCount,
+                    hasMore: result.hasMore,
+                }),
+            }],
+    };
+}

package/dist/tools/relate.d.ts

@@ -0,0 +1,31 @@
+import { z } from 'zod';
+import type { ThinkingGraph } from '../engine/graph.js';
+export declare const relateSchema: z.ZodObject<{
+    sourceId: z.ZodString;
+    targetId: z.ZodString;
+    type: z.ZodEnum<["depends_on", "contradicts", "supports", "refines", "supersedes", "similar_to", "located_in", "violates", "addresses", "detected_by", "invoked_by"]>;
+    weight: z.ZodOptional<z.ZodNumber>;
+    reasoning: z.ZodOptional<z.ZodString>;
+    bidirectional: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    type: "depends_on" | "contradicts" | "supports" | "refines" | "supersedes" | "similar_to" | "located_in" | "violates" | "addresses" | "detected_by" | "invoked_by";
+    sourceId: string;
+    targetId: string;
+    weight?: number | undefined;
+    reasoning?: string | undefined;
+    bidirectional?: boolean | undefined;
+}, {
+    type: "depends_on" | "contradicts" | "supports" | "refines" | "supersedes" | "similar_to" | "located_in" | "violates" | "addresses" | "detected_by" | "invoked_by";
+    sourceId: string;
+    targetId: string;
+    weight?: number | undefined;
+    reasoning?: string | undefined;
+    bidirectional?: boolean | undefined;
+}>;
+export type RelateInput = z.infer<typeof relateSchema>;
+export declare function relateHandler(graph: ThinkingGraph, input: RelateInput): Promise<{
+    content: {
+        type: "text";
+        text: string;
+    }[];
+}>;

package/dist/tools/relate.js

@@ -0,0 +1,58 @@
+import { z } from 'zod';
+import { EDGE_TYPES } from '../engine/types.js';
+export const relateSchema = z.object({
+    sourceId: z.string().describe('Node ID (prefix with "?" for content search)'),
+    targetId: z.string().describe('Node ID, content search, or principle name'),
+    type: z.enum(EDGE_TYPES).describe('Relationship type'),
+    weight: z.number().min(0).max(1).optional().describe('Confidence 0-1'),
+    reasoning: z.string().optional().describe('Why this relationship exists'),
+    bidirectional: z.boolean().optional().describe('Create reverse edge too'),
+});
+async function resolveId(graph, id) {
+    if (id.startsWith('?')) {
+        const query = id.slice(1);
+        // Try principle name first (e.g., "?orthogonality")
+        const principleId = `principle-${query.toLowerCase().replace(/\s+/g, '-')}`;
+        const principle = await graph.getNode(principleId);
+        if (principle)
+            return principleId;
+        // Fall back to content search
+        const results = await graph.searchNodes(query, 1);
+        if (results.length > 0)
+            return results[0].id;
+        throw new Error(`No node found matching: ${query}`);
+    }
+    return id;
+}
+export async function relateHandler(graph, input) {
+    const sourceId = await resolveId(graph, input.sourceId);
+    const targetId = await resolveId(graph, input.targetId);
+    const result = await graph.addEdge({
+        sourceId,
+        targetId,
+        type: input.type,
+        weight: input.weight,
+        reasoning: input.reasoning,
+    });
+    if (input.bidirectional) {
+        await graph.addEdge({
+            sourceId: targetId,
+            targetId: sourceId,
+            type: input.type,
+            weight: input.weight,
+            reasoning: input.reasoning,
+        });
+    }
+    return {
+        content: [{
+                type: 'text',
+                text: JSON.stringify({
+                    edgeId: result.id,
+                    sourceId,
+                    targetId,
+                    type: input.type,
+                    created: result.created,
+                }),
+            }],
+    };
+}

package/dist/tools/think.d.ts

@@ -0,0 +1,75 @@
+import { z } from 'zod';
+import type { ThinkingGraph } from '../engine/graph.js';
+export declare const thinkSchema: z.ZodObject<{
+    thought: z.ZodString;
+    type: z.ZodDefault<z.ZodEnum<["thought", "decision", "insight", "code_fact", "assumption", "detection", "tech_debt", "principle", "pattern", "skill_result", "research"]>>;
+    thoughtNumber: z.ZodNumber;
+    totalThoughts: z.ZodNumber;
+    nextThoughtNeeded: z.ZodBoolean;
+    sessionId: z.ZodOptional<z.ZodString>;
+    projectId: z.ZodOptional<z.ZodString>;
+    relates: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        type: z.ZodEnum<["depends_on", "contradicts", "supports", "refines", "supersedes", "similar_to", "located_in", "violates", "addresses", "detected_by", "invoked_by"]>;
+        targetId: z.ZodString;
+        reasoning: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        type: "depends_on" | "contradicts" | "supports" | "refines" | "supersedes" | "similar_to" | "located_in" | "violates" | "addresses" | "detected_by" | "invoked_by";
+        targetId: string;
+        reasoning?: string | undefined;
+    }, {
+        type: "depends_on" | "contradicts" | "supports" | "refines" | "supersedes" | "similar_to" | "located_in" | "violates" | "addresses" | "detected_by" | "invoked_by";
+        targetId: string;
+        reasoning?: string | undefined;
+    }>, "many">>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    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;
+    type: "thought" | "decision" | "insight" | "code_fact" | "assumption" | "detection" | "tech_debt" | "principle" | "pattern" | "skill_result" | "research";
+    thoughtNumber: number;
+    totalThoughts: number;
+    nextThoughtNeeded: boolean;
+    sessionId?: string | undefined;
+    projectId?: string | undefined;
+    metadata?: Record<string, unknown> | undefined;
+    branchId?: string | undefined;
+    isRevision?: boolean | undefined;
+    revisesThought?: number | undefined;
+    relates?: {
+        type: "depends_on" | "contradicts" | "supports" | "refines" | "supersedes" | "similar_to" | "located_in" | "violates" | "addresses" | "detected_by" | "invoked_by";
+        targetId: string;
+        reasoning?: string | undefined;
+    }[] | undefined;
+    branchFromThought?: number | undefined;
+    needsMoreThoughts?: boolean | undefined;
+}, {
+    thought: string;
+    thoughtNumber: number;
+    totalThoughts: number;
+    nextThoughtNeeded: boolean;
+    type?: "thought" | "decision" | "insight" | "code_fact" | "assumption" | "detection" | "tech_debt" | "principle" | "pattern" | "skill_result" | "research" | undefined;
+    sessionId?: string | undefined;
+    projectId?: string | undefined;
+    metadata?: Record<string, unknown> | undefined;
+    branchId?: string | undefined;
+    isRevision?: boolean | undefined;
+    revisesThought?: number | undefined;
+    relates?: {
+        type: "depends_on" | "contradicts" | "supports" | "refines" | "supersedes" | "similar_to" | "located_in" | "violates" | "addresses" | "detected_by" | "invoked_by";
+        targetId: string;
+        reasoning?: string | undefined;
+    }[] | undefined;
+    branchFromThought?: number | undefined;
+    needsMoreThoughts?: boolean | undefined;
+}>;
+export type ThinkInput = z.infer<typeof thinkSchema>;
+export declare function thinkHandler(graph: ThinkingGraph, input: ThinkInput): Promise<{
+    content: {
+        type: "text";
+        text: string;
+    }[];
+}>;

package/dist/tools/think.js

@@ -0,0 +1,69 @@
+import { z } from 'zod';
+import { NODE_TYPES, EDGE_TYPES } from '../engine/types.js';
+export const thinkSchema = z.object({
+    thought: z.string().describe('The reasoning content'),
+    type: z.enum(NODE_TYPES).default('thought').describe('Node type'),
+    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'),
+    sessionId: z.string().optional().describe('Session ID (auto-generated if omitted)'),
+    projectId: z.string().optional().describe('Project ID (detected from cwd if omitted)'),
+    relates: z.array(z.object({
+        type: z.enum(EDGE_TYPES),
+        targetId: z.string().describe('Node ID or "previous"'),
+        reasoning: z.string().optional(),
+    })).optional().describe('Inline relationships'),
+    metadata: z.record(z.unknown()).optional().describe('Flexible metadata'),
+    // Backward compat
+    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 thinkHandler(graph, input) {
+    const session = input.sessionId
+        ? (await graph.storage.getSession(input.sessionId)) ?? await graph.createSession({ id: input.sessionId })
+        : await graph.getCurrentSession();
+    const node = await graph.addNode({
+        type: input.type,
+        content: input.thought,
+        sessionId: session.id,
+        projectId: input.projectId,
+        metadata: input.metadata ?? {},
+        thoughtNumber: input.thoughtNumber,
+        totalThoughts: input.totalThoughts,
+        branchId: input.branchId,
+        isRevision: input.isRevision,
+        revisesThought: input.revisesThought,
+    });
+    await graph.touchSession(session.id);
+    // Create inline relationships
+    let relatedCount = 0;
+    if (input.relates) {
+        for (const rel of input.relates) {
+            await graph.addEdge({
+                sourceId: node.id,
+                targetId: rel.targetId,
+                type: rel.type,
+                reasoning: rel.reasoning,
+            });
+            relatedCount++;
+        }
+    }
+    const stats = await graph.storage.getStats();
+    return {
+        content: [{
+                type: 'text',
+                text: JSON.stringify({
+                    nodeId: node.id,
+                    thoughtNumber: node.thoughtNumber,
+                    totalThoughts: node.totalThoughts,
+                    nextThoughtNeeded: input.nextThoughtNeeded,
+                    branches: [],
+                    thoughtHistoryLength: stats.totalNodes,
+                    relatedNodes: relatedCount,
+                }),
+            }],
+    };
+}

package/migrations/001-initial.sql

@@ -0,0 +1,108 @@
+-- Thinking Graph Schema v1
+-- Sessions, Nodes (with FTS5), Edges, Skill Registry
+
+PRAGMA journal_mode = WAL;
+PRAGMA foreign_keys = ON;
+
+-- ─── Sessions ────────────────────────────────────────────
+
+CREATE TABLE IF NOT EXISTS sessions (
+  id            TEXT PRIMARY KEY,
+  project_id    TEXT,
+  project_path  TEXT,
+  description   TEXT,
+  started_at    TEXT NOT NULL DEFAULT (datetime('now')),
+  last_active   TEXT NOT NULL DEFAULT (datetime('now'))
+);
+
+CREATE INDEX IF NOT EXISTS idx_sessions_project ON sessions(project_id);
+
+-- ─── Nodes ───────────────────────────────────────────────
+
+CREATE TABLE IF NOT EXISTS nodes (
+  id              TEXT PRIMARY KEY,
+  type            TEXT NOT NULL CHECK (type IN (
+                    'thought','decision','insight','code_fact','assumption',
+                    'detection','tech_debt','principle','pattern',
+                    'skill_result','research'
+                  )),
+  content         TEXT NOT NULL,
+  session_id      TEXT REFERENCES sessions(id),
+  project_id      TEXT,
+  metadata        TEXT DEFAULT '{}',
+  created_at      TEXT NOT NULL DEFAULT (datetime('now')),
+  updated_at      TEXT NOT NULL DEFAULT (datetime('now')),
+
+  -- Backward compat with sequential-thinking
+  thought_number  INTEGER,
+  total_thoughts  INTEGER,
+  branch_id       TEXT,
+  is_revision     INTEGER DEFAULT 0,
+  revises_thought INTEGER
+);
+
+CREATE INDEX IF NOT EXISTS idx_nodes_type    ON nodes(type);
+CREATE INDEX IF NOT EXISTS idx_nodes_session ON nodes(session_id);
+CREATE INDEX IF NOT EXISTS idx_nodes_project ON nodes(project_id);
+CREATE INDEX IF NOT EXISTS idx_nodes_branch  ON nodes(branch_id);
+CREATE INDEX IF NOT EXISTS idx_nodes_created ON nodes(created_at);
+
+-- Full-text search
+CREATE VIRTUAL TABLE IF NOT EXISTS nodes_fts USING fts5(
+  content,
+  content='nodes',
+  content_rowid='rowid'
+);
+
+-- Keep FTS in sync
+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;
+
+-- ─── Edges ───────────────────────────────────────────────
+
+CREATE TABLE IF NOT EXISTS edges (
+  id            TEXT PRIMARY KEY,
+  source_id     TEXT NOT NULL REFERENCES nodes(id) ON DELETE CASCADE,
+  target_id     TEXT NOT NULL REFERENCES nodes(id) ON DELETE CASCADE,
+  type          TEXT NOT NULL CHECK (type IN (
+                  'depends_on','contradicts','supports','refines',
+                  'supersedes','similar_to','located_in','violates',
+                  'addresses','detected_by','invoked_by'
+                )),
+  weight        REAL DEFAULT 1.0 CHECK (weight >= 0 AND weight <= 1),
+  reasoning     TEXT,
+  created_at    TEXT NOT NULL DEFAULT (datetime('now')),
+
+  UNIQUE(source_id, target_id, type)
+);
+
+CREATE INDEX IF NOT EXISTS idx_edges_source ON edges(source_id);
+CREATE INDEX IF NOT EXISTS idx_edges_target ON edges(target_id);
+CREATE INDEX IF NOT EXISTS idx_edges_type   ON edges(type);
+
+-- ─── Skill Registry ──────────────────────────────────────
+
+CREATE TABLE IF NOT EXISTS skill_registry (
+  id            TEXT PRIMARY KEY,
+  plugin_name   TEXT NOT NULL,
+  skill_name    TEXT NOT NULL,
+  verb          TEXT,
+  invocation    TEXT NOT NULL,
+  areas         TEXT DEFAULT '[]',
+  detects       TEXT DEFAULT '[]',
+  produces      TEXT DEFAULT '[]',
+  invokes       TEXT DEFAULT '[]',
+  platform      TEXT,
+
+  UNIQUE(plugin_name, skill_name)
+);

package/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "@feelingmindful/thinking-graph",
+  "version": "1.2.0",
+  "description": "Persistent graph-based MCP thinking server for the feeling-mindful plugin marketplace",
+  "type": "module",
+  "main": "dist/index.js",
+  "bin": {
+    "thinking-graph": "dist/index.js"
+  },
+  "files": [
+    "dist",
+    "migrations",
+    "seeds"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/feeling-mindful/feeling-mindful-plugins.git",
+    "directory": "plugins/premium-core/mcp-servers/thinking-graph"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org"
+  },
+  "scripts": {
+    "build": "tsc",
+    "prepublishOnly": "npm run build",
+    "dev": "tsc --watch",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "start": "node dist/index.js"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.12.0",
+    "better-sqlite3": "^11.0.0",
+    "zod": "^3.23.0",
+    "uuid": "^10.0.0"
+  },
+  "devDependencies": {
+    "vitest": "^3.0.0",
+    "typescript": "^5.5.0",
+    "@types/better-sqlite3": "^7.6.0",
+    "@types/uuid": "^10.0.0"
+  }
+}