@iwo-szapar/data-mcp 0.2.1 → 0.3.2

package/README.md

@@ -0,0 +1,286 @@
+# @iwo-szapar/data-mcp
+
+Unified data MCP server for [Second Brain](https://iwoszapar.com/second-brain-ai). One MCP, two backends: PocketBase (local, free) or Supabase (cloud, multi-device).
+
+40 tools across knowledge, sessions, goals, tasks, contacts, CRM prospects, blog, email queue, and content calendar. Used in production by Second Brain v2 customers.
+
+---
+
+## Install
+
+```bash
+npm install -g @iwo-szapar/data-mcp
+# or run on demand
+npx @iwo-szapar/data-mcp
+```
+
+Requires Node.js `>=20`.
+
+---
+
+## Quick start — PocketBase (local)
+
+PocketBase runs on your laptop. Good for single-device workflows. Stops when you close the terminal.
+
+1. **Install PocketBase** ([pocketbase.io](https://pocketbase.io)) and start it:
+
+   ```bash
+   ./pocketbase serve
+   # Admin UI: http://127.0.0.1:8090/_/
+   ```
+
+2. **Create an admin account** via the Admin UI on first run.
+
+3. **Apply the schema migrations** (required — the MCP does NOT apply them automatically):
+
+   Copy the files in `migrations/pocketbase/` (shipped with this package) into your PocketBase instance's `pb_migrations/` directory, then run:
+
+   ```bash
+   ./pocketbase migrate up
+   ```
+
+   This creates all 14 collections (`knowledge`, `decisions`, `sessions`, `goals`, `tasks`, `contacts`, `entity_aliases`, `settings`, `prospects`, `blog_posts`, `email_queue`, `content_calendar`, `newsletter_subscribers`, `affiliates`).
+
+4. **Configure your MCP client** (Claude Code, Claude Desktop, Cursor, etc.):
+
+   ```json
+   {
+     "mcpServers": {
+       "data-mcp": {
+         "command": "npx",
+         "args": ["-y", "@iwo-szapar/data-mcp"],
+         "env": {
+           "SB_BACKEND": "pocketbase",
+           "SB_POCKETBASE_URL": "http://127.0.0.1:8090",
+           "SB_POCKETBASE_ADMIN_EMAIL": "you@example.com",
+           "SB_POCKETBASE_ADMIN_PASSWORD": "your-admin-password"
+         }
+       }
+     }
+   }
+   ```
+
+5. **Verify**: in your MCP client, call the `setup_status` tool. It reports which collections exist and flags any missing ones.
+
+---
+
+## Quick start — Supabase (cloud, multi-device)
+
+Supabase is a hosted Postgres. Runs 24/7, reachable from any device. Good for multi-device setups and phone-friendly workflows.
+
+1. **Create a Supabase project** at [supabase.com](https://supabase.com). Note the Project URL and `service_role` key (Settings → API).
+
+2. **Apply the SQL migrations** via the SQL editor or the Supabase CLI:
+
+   ```bash
+   # Using the Supabase CLI
+   for f in migrations/supabase/*.sql; do
+     psql "$SUPABASE_DB_URL" -f "$f"
+   done
+   ```
+
+   Apply them in order `001` through `010`. The MCP does NOT apply them automatically.
+
+3. **Configure your MCP client**:
+
+   ```json
+   {
+     "mcpServers": {
+       "data-mcp": {
+         "command": "npx",
+         "args": ["-y", "@iwo-szapar/data-mcp"],
+         "env": {
+           "SB_BACKEND": "supabase",
+           "SB_SUPABASE_URL": "https://YOUR_PROJECT.supabase.co",
+           "SB_SUPABASE_KEY": "your-service-role-key"
+         }
+       }
+     }
+   }
+   ```
+
+   Use the `service_role` key, not `anon`. The MCP needs full access.
+
+4. **Verify** with `setup_status`.
+
+---
+
+## Environment variables
+
+| Variable | Required | Applies to | Description |
+|---|---|---|---|
+| `SB_BACKEND` | yes | both | `pocketbase` or `supabase` |
+| `SB_POCKETBASE_URL` | yes (PB) | pocketbase | e.g. `http://127.0.0.1:8090` |
+| `SB_POCKETBASE_ADMIN_EMAIL` | yes (PB) | pocketbase | PocketBase admin email |
+| `SB_POCKETBASE_ADMIN_PASSWORD` | yes (PB) | pocketbase | PocketBase admin password |
+| `SB_SUPABASE_URL` | yes (SB) | supabase | Project URL |
+| `SB_SUPABASE_KEY` | yes (SB) | supabase | `service_role` key |
+| `SB_SCHEMA_MAP` | no | both | JSON object mapping logical names to real table names (e.g. `{"prospects":"my_leads"}`) |
+| `SB_RESEND_API_KEY` | no | both | Resend key for email tooling (optional) |
+
+Missing any required var on startup → the server exits with `Missing required environment variable: SB_XXX`.
+
+---
+
+## Tool reference (40 tools)
+
+All tools return JSON. Every tool uses *graceful degradation*: if the required table doesn't exist, the tool returns a clear error asking you to apply migrations instead of crashing.
+
+### Knowledge (8)
+
+| Tool | Purpose |
+|---|---|
+| `knowledge_store` | Store a fact / pattern / insight / lesson / reference. Dedup by `(type, title)`. |
+| `knowledge_recall` | Search knowledge by query, tags, or type. |
+| `knowledge_learn` | Shortcut for storing a `lesson`. |
+| `knowledge_decide` | Record a decision with context, options, chosen option, and rationale (writes to `decisions`). |
+| `knowledge_validate` | Mark an item as freshly validated (resets `last_validated_at`). |
+| `knowledge_update` | Update title / content / tags on an existing item. |
+| `knowledge_delete` | Delete a knowledge item by ID. |
+| `knowledge_list` | List or filter knowledge items. |
+
+### Sessions (2)
+
+| Tool | Purpose |
+|---|---|
+| `session_log` | Log a completed work session with skills used, files changed, decisions made. |
+| `session_list` | List recent sessions. |
+
+### Goals (3)
+
+| Tool | Purpose |
+|---|---|
+| `goal_create` / `goal_update` / `goal_list` | Track goals with key results. |
+
+### Tasks (3)
+
+| Tool | Purpose |
+|---|---|
+| `task_create` / `task_update` / `task_list` | Task management with status and priority. |
+
+### Contacts (4)
+
+| Tool | Purpose |
+|---|---|
+| `contact_create` / `contact_update` / `contact_list` / `contact_search` | Contact records with relationship type and tags. |
+
+### Brain health (2)
+
+| Tool | Purpose |
+|---|---|
+| `brain_stats` | Aggregate counts across collections and knowledge-type distribution. |
+| `brain_decay` | Find stale knowledge items (not validated recently). |
+
+### Knowledge links (4)
+
+| Tool | Purpose |
+|---|---|
+| `link_create` / `link_delete` / `link_related` / `link_suggest` | Graph-lite relationships between knowledge items. |
+
+### Setup (3)
+
+| Tool | Purpose |
+|---|---|
+| `setup_status` | Report which collections exist. **Run this first** after installation. |
+| `setup_migrate` | **Reports** missing collections and points to the migration files. Does **not** apply migrations automatically — you must run them via PocketBase CLI or `psql`. |
+| `setup_seed` | Load seed data (e.g. `entity_aliases` for search). |
+
+### CRM prospects (4)
+
+| Tool | Purpose |
+|---|---|
+| `prospect_create` / `prospect_update` / `prospect_list` / `prospect_search` | Sales pipeline. Stages: `new → contacted → responded → interested → ready_to_buy → proposal_sent → negotiating → closed_won / closed_lost / nurturing`. |
+
+### Blog (4)
+
+| Tool | Purpose |
+|---|---|
+| `blog_create` / `blog_update` / `blog_list` / `blog_delete` | Blog post content management. |
+
+### Email + content queues (3)
+
+| Tool | Purpose |
+|---|---|
+| `email_queue_add` | Queue an email (does NOT send — sending is done out-of-band). |
+| `content_queue_add` / `content_queue_list` | Content calendar for scheduled posts. |
+
+---
+
+## Common failures (and how to recover)
+
+### "The 'X' table does not exist yet. Run setup_migrate to create the database schema."
+
+**What it means:** The collection backing this tool hasn't been created.
+
+**Fix:** `setup_migrate` only *reports* missing tables — it does not apply them. You need to run the actual migrations:
+
+- **PocketBase:** `./pocketbase migrate up` (after copying the files in `migrations/pocketbase/` into your `pb_migrations/` directory).
+- **Supabase:** run each file in `migrations/supabase/` in order via the SQL editor or `psql`.
+
+Then call `setup_status` to confirm.
+
+### "Only knowledge tools work, everything else fails"
+
+**Symptom:** `knowledge_store` and `knowledge_recall` succeed but `goal_create`, `task_create`, `contact_create` all return the "table does not exist" error.
+
+**Cause:** You applied only the first migration (`001_core_schema`) which creates `knowledge`, `decisions`, and `sessions`. The rest of the collections come from migrations `002` through `010` (Supabase) or `002` through `008` (PocketBase).
+
+**Fix:** Apply all migrations in order.
+
+### PocketBase disconnects between terminal sessions
+
+**Cause:** `pocketbase serve` runs in the foreground. When you close the terminal, the server stops.
+
+**Fix options:**
+- Run PocketBase under a process manager (pm2, forever) or a launchd plist on macOS.
+- Switch to the Supabase backend — it runs 24/7 in the cloud.
+
+### MCP server disconnected after Claude Code restart
+
+**Cause:** Your MCP client is not reading the server config on startup, or the `npx -y` download got interrupted.
+
+**Fix:** Install globally once (`npm install -g @iwo-szapar/data-mcp`) and point `command` at `data-mcp` instead of `npx`. Restart your MCP client.
+
+### "Database authentication failed"
+
+**PocketBase:** check `SB_POCKETBASE_ADMIN_EMAIL` / `PASSWORD` match an admin account in the Admin UI.
+
+**Supabase:** confirm you are using the `service_role` key, not `anon`. The anon key does not have write access to these tables.
+
+---
+
+## Schema mapping (optional)
+
+If your real tables have different names, set `SB_SCHEMA_MAP` to a JSON object:
+
+```bash
+SB_SCHEMA_MAP='{"prospects":"sales_leads","contacts":"people"}'
+```
+
+Logical names used by the tools (`prospects`, `contacts`, etc.) are transparently rewritten to your real table names. Empty keys or missing keys pass through unchanged.
+
+---
+
+## File layout
+
+```
+dist/              compiled JS (entry: dist/index.js)
+migrations/
+  pocketbase/      *.js migration files (PocketBase migrate format)
+  supabase/        *.sql migration files (run in order)
+seed/              seed data (entity_aliases.json, etc.)
+```
+
+The published package ships `dist/`, `migrations/`, `seed/`.
+
+---
+
+## License
+
+MIT
+
+---
+
+## Support
+
+This package is maintained by [Iwo Szapar](https://iwoszapar.com) as part of the Second Brain ecosystem. For issues specific to Second Brain v2 customers, reply to your purchase confirmation email. For general bugs, open an issue against the package on npm.

package/dist/server.js

@@ -29,8 +29,8 @@ const SERVER_INSTRUCTIONS = `You are the user's AI Second Brain data layer. This
 - Use setup_status to check database readiness`;
 export function createServer(adapter) {
     const server = new McpServer({
-        name: '@second-brain/data-mcp',
-        version: '0.1.0',
+        name: '@iwo-szapar/data-mcp',
+        version: '0.3.2',
     }, {
         instructions: SERVER_INSTRUCTIONS,
     });

package/dist/tools/memory/link-create.d.ts

@@ -0,0 +1,4 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { DataAdapter } from '../../adapter/types.js';
+export declare function registerLinkCreate(server: McpServer, adapter: DataAdapter): void;
+//# sourceMappingURL=link-create.d.ts.map

package/dist/tools/memory/link-create.js

@@ -0,0 +1,67 @@
+/**
+ * Tool: link_create
+ *
+ * Creates a typed relationship between two MemoryOS entities.
+ */
+import { z } from 'zod';
+import { makeToolResponse, handleAdapterError, withGracefulDegradation } from '../shared.js';
+const ENTITY_TYPES = ['knowledge', 'decision', 'session', 'blog_post', 'prospect', 'agent_learning'];
+const RELATION_TYPES = ['supports', 'contradicts', 'derived_from', 'example_of', 'supersedes', 'part_of', 'prerequisite'];
+export function registerLinkCreate(server, adapter) {
+    server.tool('link_create', 'Create a typed relationship between two MemoryOS entities. ' +
+        'Links express how knowledge items relate: supports, contradicts, derived_from, etc. ' +
+        'Deduplicates by (source, target, relation_type).', {
+        source_type: z.enum(ENTITY_TYPES).describe('Type of the source entity'),
+        source_id: z.string().uuid().describe('UUID of the source entity'),
+        target_type: z.enum(ENTITY_TYPES).describe('Type of the target entity'),
+        target_id: z.string().uuid().describe('UUID of the target entity'),
+        relation_type: z.enum(RELATION_TYPES).describe('Type of relationship'),
+        confidence: z.number().min(0).max(1).optional().default(0.8).describe('Confidence in this relationship (0-1)'),
+        notes: z.string().max(500).optional().describe('Optional context for why this link exists'),
+    }, withGracefulDegradation('knowledge_links', adapter, async (params) => {
+        try {
+            if (params.source_type === params.target_type && params.source_id === params.target_id) {
+                return makeToolResponse({
+                    created: false,
+                    message: 'Cannot create a self-link.',
+                });
+            }
+            const existing = await adapter.list('knowledge_links', {
+                filter: [[
+                        { field: 'source_type', op: 'eq', value: params.source_type },
+                        { field: 'source_id', op: 'eq', value: params.source_id },
+                        { field: 'target_type', op: 'eq', value: params.target_type },
+                        { field: 'target_id', op: 'eq', value: params.target_id },
+                        { field: 'relation_type', op: 'eq', value: params.relation_type },
+                    ]],
+                page: { limit: 1, offset: 0 },
+            });
+            if (existing.items.length > 0) {
+                return makeToolResponse({
+                    created: false,
+                    existing_link_id: existing.items[0].id,
+                    message: `Link already exists (id: ${existing.items[0].id}).`,
+                });
+            }
+            const record = await adapter.create('knowledge_links', {
+                source_type: params.source_type,
+                source_id: params.source_id,
+                target_type: params.target_type,
+                target_id: params.target_id,
+                relation_type: params.relation_type,
+                confidence: params.confidence ?? 0.8,
+                notes: params.notes ?? null,
+                auto_suggested: false,
+            });
+            return makeToolResponse({
+                created: true,
+                link: { id: record.id, source_type: params.source_type, target_type: params.target_type, relation_type: params.relation_type },
+                message: `Link created: ${params.source_type}:${params.source_id.slice(0, 8)} --[${params.relation_type}]--> ${params.target_type}:${params.target_id.slice(0, 8)}`,
+            });
+        }
+        catch (error) {
+            return handleAdapterError(error, 'link_create');
+        }
+    }));
+}
+//# sourceMappingURL=link-create.js.map

package/dist/tools/memory/link-delete.d.ts

@@ -0,0 +1,4 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { DataAdapter } from '../../adapter/types.js';
+export declare function registerLinkDelete(server: McpServer, adapter: DataAdapter): void;
+//# sourceMappingURL=link-delete.d.ts.map

package/dist/tools/memory/link-delete.js

@@ -0,0 +1,27 @@
+/**
+ * Tool: link_delete
+ *
+ * Deletes a knowledge link by ID.
+ */
+import { z } from 'zod';
+import { makeToolResponse, handleAdapterError, withGracefulDegradation } from '../shared.js';
+export function registerLinkDelete(server, adapter) {
+    server.tool('link_delete', 'Delete a knowledge link by its ID.', {
+        link_id: z.string().uuid().describe('UUID of the link to delete'),
+    }, withGracefulDegradation('knowledge_links', adapter, async (params) => {
+        try {
+            try {
+                await adapter.getOne('knowledge_links', params.link_id);
+            }
+            catch {
+                return makeToolResponse({ deleted: false, message: `Link not found: ${params.link_id}` });
+            }
+            await adapter.delete('knowledge_links', params.link_id);
+            return makeToolResponse({ deleted: true, link_id: params.link_id, message: `Link deleted: ${params.link_id}` });
+        }
+        catch (error) {
+            return handleAdapterError(error, 'link_delete');
+        }
+    }));
+}
+//# sourceMappingURL=link-delete.js.map

package/dist/tools/memory/link-related.d.ts

@@ -0,0 +1,4 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { DataAdapter } from '../../adapter/types.js';
+export declare function registerLinkRelated(server: McpServer, adapter: DataAdapter): void;
+//# sourceMappingURL=link-related.d.ts.map

package/dist/tools/memory/link-related.js

@@ -0,0 +1,91 @@
+/**
+ * Tool: link_related
+ *
+ * Get all links for an entity — traverse the knowledge graph.
+ */
+import { z } from 'zod';
+import { makeToolResponse, handleAdapterError, withGracefulDegradation } from '../shared.js';
+const ENTITY_TYPES = ['knowledge', 'decision', 'session', 'blog_post', 'prospect', 'agent_learning'];
+export function registerLinkRelated(server, adapter) {
+    server.tool('link_related', 'Get all links for an entity. Shows outgoing and incoming relationships with resolved titles.', {
+        entity_type: z.enum(ENTITY_TYPES).describe('Type of the entity'),
+        entity_id: z.string().uuid().describe('UUID of the entity'),
+        direction: z.enum(['both', 'outgoing', 'incoming']).optional().default('both').describe('Filter direction'),
+        relation_type: z.enum(['supports', 'contradicts', 'derived_from', 'example_of', 'supersedes', 'part_of', 'prerequisite'])
+            .optional().describe('Filter by relation type'),
+    }, withGracefulDegradation('knowledge_links', adapter, async (params) => {
+        try {
+            const outgoing = [];
+            const incoming = [];
+            if (params.direction === 'both' || params.direction === 'outgoing') {
+                const filter = [
+                    { field: 'source_type', op: 'eq', value: params.entity_type },
+                    { field: 'source_id', op: 'eq', value: params.entity_id },
+                ];
+                if (params.relation_type) {
+                    filter.push({ field: 'relation_type', op: 'eq', value: params.relation_type });
+                }
+                const result = await adapter.list('knowledge_links', {
+                    filter: [filter],
+                    sort: [{ field: 'created_at', direction: 'desc' }],
+                    page: { limit: 50, offset: 0 },
+                });
+                for (const link of result.items) {
+                    let targetTitle = null;
+                    try {
+                        const col = link.target_type === 'decision' ? 'decisions' : link.target_type;
+                        targetTitle = (await adapter.getOne(col, link.target_id)).title ?? null;
+                    }
+                    catch { /* skip */ }
+                    outgoing.push({
+                        link_id: link.id, direction: 'outgoing',
+                        linked_type: link.target_type, linked_id: link.target_id,
+                        linked_title: targetTitle, relation_type: link.relation_type,
+                        confidence: link.confidence, notes: link.notes,
+                    });
+                }
+            }
+            if (params.direction === 'both' || params.direction === 'incoming') {
+                const filter = [
+                    { field: 'target_type', op: 'eq', value: params.entity_type },
+                    { field: 'target_id', op: 'eq', value: params.entity_id },
+                ];
+                if (params.relation_type) {
+                    filter.push({ field: 'relation_type', op: 'eq', value: params.relation_type });
+                }
+                const result = await adapter.list('knowledge_links', {
+                    filter: [filter],
+                    sort: [{ field: 'created_at', direction: 'desc' }],
+                    page: { limit: 50, offset: 0 },
+                });
+                for (const link of result.items) {
+                    let sourceTitle = null;
+                    try {
+                        const col = link.source_type === 'decision' ? 'decisions' : link.source_type;
+                        sourceTitle = (await adapter.getOne(col, link.source_id)).title ?? null;
+                    }
+                    catch { /* skip */ }
+                    incoming.push({
+                        link_id: link.id, direction: 'incoming',
+                        linked_type: link.source_type, linked_id: link.source_id,
+                        linked_title: sourceTitle, relation_type: link.relation_type,
+                        confidence: link.confidence, notes: link.notes,
+                    });
+                }
+            }
+            const allLinks = [...outgoing, ...incoming];
+            return makeToolResponse({
+                entity_type: params.entity_type, entity_id: params.entity_id,
+                total_links: allLinks.length, outgoing_count: outgoing.length, incoming_count: incoming.length,
+                links: allLinks,
+                message: allLinks.length === 0
+                    ? `No links found. Use link_suggest to find potential connections.`
+                    : `Found ${allLinks.length} links (${outgoing.length} outgoing, ${incoming.length} incoming).`,
+            });
+        }
+        catch (error) {
+            return handleAdapterError(error, 'link_related');
+        }
+    }));
+}
+//# sourceMappingURL=link-related.js.map

package/dist/tools/memory/link-suggest.d.ts

@@ -0,0 +1,4 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { DataAdapter } from '../../adapter/types.js';
+export declare function registerLinkSuggest(server: McpServer, adapter: DataAdapter): void;
+//# sourceMappingURL=link-suggest.d.ts.map

package/dist/tools/memory/link-suggest.js

@@ -0,0 +1,83 @@
+/**
+ * Tool: link_suggest
+ *
+ * Find similar items and suggest links using keyword matching.
+ */
+import { z } from 'zod';
+import { makeToolResponse, handleAdapterError, withGracefulDegradation } from '../shared.js';
+export function registerLinkSuggest(server, adapter) {
+    server.tool('link_suggest', 'Find knowledge items similar to a given item and suggest links. ' +
+        'Uses text search to find related items. Returns matches with suggested relation types.', {
+        item_id: z.string().uuid().describe('UUID of the knowledge item to find suggestions for'),
+        limit: z.number().min(1).max(20).optional().default(5).describe('Max suggestions'),
+    }, withGracefulDegradation('knowledge', adapter, async (params) => {
+        try {
+            let sourceItem;
+            try {
+                sourceItem = await adapter.getOne('knowledge', params.item_id);
+            }
+            catch {
+                return makeToolResponse({ suggestions: [], message: `Item not found: ${params.item_id}` });
+            }
+            // Get already-linked IDs to exclude
+            const linkedIds = new Set();
+            try {
+                const out = await adapter.list('knowledge_links', {
+                    filter: [[{ field: 'source_type', op: 'eq', value: 'knowledge' }, { field: 'source_id', op: 'eq', value: params.item_id }]],
+                    page: { limit: 100, offset: 0 },
+                });
+                const inc = await adapter.list('knowledge_links', {
+                    filter: [[{ field: 'target_type', op: 'eq', value: 'knowledge' }, { field: 'target_id', op: 'eq', value: params.item_id }]],
+                    page: { limit: 100, offset: 0 },
+                });
+                for (const l of out.items) linkedIds.add(l.target_id);
+                for (const l of inc.items) linkedIds.add(l.source_id);
+            }
+            catch { /* knowledge_links may not exist */ }
+            const searchTerms = extractKeyTerms(sourceItem.title, sourceItem.content);
+            let suggestions = [];
+            if (searchTerms) {
+                const results = await adapter.textSearch('knowledge', searchTerms, {
+                    limit: (params.limit ?? 5) + linkedIds.size + 1,
+                });
+                suggestions = results
+                    .filter(item => item.id !== params.item_id && !linkedIds.has(item.id))
+                    .slice(0, params.limit ?? 5)
+                    .map(item => ({
+                    id: item.id, type: item.type, title: item.title,
+                    summary: item.summary ?? (item.content?.slice(0, 100) + '...'),
+                    suggested_relation: suggestRelationType(sourceItem, item),
+                }));
+            }
+            return makeToolResponse({
+                source: { id: sourceItem.id, type: sourceItem.type, title: sourceItem.title },
+                suggestions, already_linked: linkedIds.size,
+                message: suggestions.length === 0
+                    ? `No unlinked similar items found for "${sourceItem.title}".`
+                    : `Found ${suggestions.length} suggestions. Use link_create to connect them.`,
+            });
+        }
+        catch (error) {
+            return handleAdapterError(error, 'link_suggest');
+        }
+    }));
+}
+function extractKeyTerms(title, content) {
+    const stopWords = new Set(['the', 'a', 'an', 'is', 'are', 'was', 'were', 'be', 'been', 'being',
+        'have', 'has', 'had', 'do', 'does', 'did', 'will', 'would', 'could', 'should', 'may',
+        'might', 'can', 'to', 'of', 'in', 'for', 'on', 'with', 'at', 'by', 'from', 'as',
+        'and', 'but', 'or', 'not', 'so', 'if', 'when', 'how', 'what', 'which', 'who',
+        'this', 'that', 'these', 'those', 'it', 'its']);
+    const text = `${title} ${(content ?? '').slice(0, 200)}`;
+    const words = text.toLowerCase().replace(/[^a-z0-9\s]/g, ' ').split(/\s+/)
+        .filter(w => w.length > 2 && !stopWords.has(w));
+    return [...new Set(words)].slice(0, 5).join(' ');
+}
+function suggestRelationType(source, target) {
+    if (source.type === target.type) return 'supports';
+    if ((source.type === 'lesson' && target.type === 'decision') || (source.type === 'decision' && target.type === 'lesson')) return 'derived_from';
+    if (source.type === 'insight' && target.type === 'pattern') return 'derived_from';
+    if (source.type === 'pattern' && target.type === 'insight') return 'example_of';
+    return 'supports';
+}
+//# sourceMappingURL=link-suggest.js.map

package/dist/tools/register.js

@@ -1,7 +1,7 @@
 /**
- * Tool registration — imports and calls all 35 register functions.
+ * Tool registration — imports and calls all 39 register functions.
  */
-// Memory tools (22)
+// Memory tools (26)
 import { registerKnowledgeStore } from './memory/knowledge-store.js';
 import { registerKnowledgeRecall } from './memory/knowledge-recall.js';
 import { registerKnowledgeLearn } from './memory/knowledge-learn.js';
@@ -24,6 +24,10 @@ import { registerContactList } from './memory/contact-list.js';
 import { registerContactSearch } from './memory/contact-search.js';
 import { registerBrainStats } from './memory/brain-stats.js';
 import { registerBrainDecay } from './memory/brain-decay.js';
+import { registerLinkCreate } from './memory/link-create.js';
+import { registerLinkDelete } from './memory/link-delete.js';
+import { registerLinkRelated } from './memory/link-related.js';
+import { registerLinkSuggest } from './memory/link-suggest.js';
 // Setup tools (3)
 import { registerSetupStatus } from './setup/setup-status.js';
 import { registerSetupMigrate } from './setup/setup-migrate.js';
@@ -64,6 +68,10 @@ export function registerAllTools(server, adapter) {
     registerContactSearch(server, adapter);
     registerBrainStats(server, adapter);
     registerBrainDecay(server, adapter);
+    registerLinkCreate(server, adapter);
+    registerLinkDelete(server, adapter);
+    registerLinkRelated(server, adapter);
+    registerLinkSuggest(server, adapter);
     // Setup tools
     registerSetupStatus(server, adapter);
     registerSetupMigrate(server, adapter);