@iwo-szapar/data-mcp 0.4.0 → 0.5.0

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: '@iwo-szapar/data-mcp',
-        version: '0.3.3',
+        name: '@second-brain/data-mcp',
+        version: '0.1.0',
     }, {
         instructions: SERVER_INSTRUCTIONS,
     });

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

@@ -12,9 +12,9 @@ export function registerLinkCreate(server, adapter) {
         '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().min(1).max(50).describe('ID of the source entity (UUID on Supabase, 15-char native ID on PocketBase)'),
+        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().min(1).max(50).describe('ID of the target entity (UUID on Supabase, 15-char native ID on PocketBase)'),
+        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'),

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

@@ -7,7 +7,7 @@ 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().min(1).max(50).describe('ID of the link to delete'),
+        link_id: z.string().uuid().describe('UUID of the link to delete'),
     }, withGracefulDegradation('knowledge_links', adapter, async (params) => {
         try {
             try {

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

@@ -9,7 +9,7 @@ const ENTITY_TYPES = ['knowledge', 'decision', 'session', 'blog_post', 'prospect
 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().min(1).max(50).describe('ID of the entity (UUID on Supabase, 15-char native ID on PocketBase)'),
+        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'),

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

@@ -8,7 +8,7 @@ import { makeToolResponse, handleAdapterError, withGracefulDegradation } from '.
 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().min(1).max(50).describe('ID of the knowledge item to find suggestions for'),
+        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 {

package/dist/tools/register.js

@@ -28,9 +28,10 @@ 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)
+// Setup tools (4)
 import { registerSetupStatus } from './setup/setup-status.js';
 import { registerSetupMigrate } from './setup/setup-migrate.js';
+import { registerSetupBootstrap } from './setup/setup-bootstrap.js';
 import { registerSetupSeed } from './setup/setup-seed.js';
 // Business tools (11)
 import { registerProspectCreate } from './business/prospect-create.js';
@@ -75,6 +76,7 @@ export function registerAllTools(server, adapter) {
     // Setup tools
     registerSetupStatus(server, adapter);
     registerSetupMigrate(server, adapter);
+    registerSetupBootstrap(server, adapter);
     registerSetupSeed(server, adapter);
     // Business tools
     registerProspectCreate(server, adapter);

package/dist/tools/setup/setup-bootstrap.js

@@ -0,0 +1,71 @@
+/**
+ * Tool: setup_bootstrap
+ *
+ * RC-2 fix (incident 2026-05-11): Generates a single SQL block containing
+ * every bundled Supabase migration concatenated in numeric order, followed
+ * by NOTIFY pgrst, 'reload schema'. Customer pastes the block into the
+ * Supabase SQL Editor and runs it once. Stops short of running the SQL
+ * itself because Supabase service-role over PostgREST does not expose
+ * arbitrary SQL execution — that needs either a custom exec_sql function
+ * (Approach B, opt-in by customer) or the Management API with a personal
+ * access token (Approach C, adds auth surface). This is Approach A: lowest
+ * friction, no new auth, works on Cloud + self-hosted.
+ *
+ * After the customer runs the block, setup_migrate will report all
+ * collections present.
+ */
+import { readFileSync, readdirSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { makeToolResponse, makeErrorResponse } from '../shared.js';
+const MIGRATIONS_DIR = join(dirname(fileURLToPath(import.meta.url)), '..', '..', '..', 'migrations', 'supabase');
+export function registerSetupBootstrap(server, adapter) {
+    server.tool('setup_bootstrap', 'Generate a paste-ready SQL block (all bundled Supabase migrations + PostgREST reload). Open the returned sql_editor_url, paste sql, run. Idempotent. Supabase backend only — PocketBase customers use setup_migrate.', {}, async () => {
+        if (adapter.backend !== 'supabase') {
+            return makeErrorResponse('setup_bootstrap is Supabase-only. PocketBase customers use setup_migrate.');
+        }
+        try {
+            const files = readdirSync(MIGRATIONS_DIR).filter((f) => f.endsWith('.sql')).sort();
+            if (files.length === 0) {
+                return makeErrorResponse(`No bundled migration files found at ${MIGRATIONS_DIR}. Package install may be corrupted.`);
+            }
+            const blocks = files.map((f) => `-- ===== ${f} =====\n${readFileSync(join(MIGRATIONS_DIR, f), 'utf-8').trimEnd()}\n`);
+            const sql = [
+                ...blocks,
+                '-- ===== Reload PostgREST schema cache =====',
+                "-- Without this, PostgREST keeps serving stale cache and knowledge_* calls fail.",
+                "NOTIFY pgrst, 'reload schema';",
+                '',
+            ].join('\n');
+            // Supabase URL format: https://<ref>.supabase.co. The SQL Editor URL is
+            // https://supabase.com/dashboard/project/<ref>/sql/new. We try to extract
+            // the ref; if the URL doesn't match the expected format (self-hosted,
+            // etc.), we fall back to the generic dashboard.
+            const supabaseUrl = adapter.supabaseUrl || '';
+            const refMatch = supabaseUrl.match(/https?:\/\/([a-z0-9]+)\.supabase\.co/);
+            const sqlEditorUrl = refMatch
+                ? `https://supabase.com/dashboard/project/${refMatch[1]}/sql/new`
+                : 'https://supabase.com/dashboard/project/_/sql/new';
+            return makeToolResponse({
+                backend: 'supabase',
+                migrations_path: MIGRATIONS_DIR,
+                files_count: files.length,
+                files,
+                sql,
+                sql_editor_url: sqlEditorUrl,
+                instructions: [
+                    `1. Open ${sqlEditorUrl}`,
+                    '2. Paste the contents of the `sql` field above into the editor.',
+                    '3. Run.',
+                    '4. Verify with setup_migrate (it should report 0 missing collections).',
+                ],
+            });
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : 'unknown';
+            console.error('[setup_bootstrap] Error:', err);
+            return makeErrorResponse(`Failed to assemble bootstrap SQL from ${MIGRATIONS_DIR}: ${msg}`);
+        }
+    });
+}
+//# sourceMappingURL=setup-bootstrap.js.map

package/dist/tools/setup/setup-migrate.js

@@ -3,8 +3,16 @@
  *
  * Apply migrations — additive only, skips existing collections.
  * Creates all expected collections in the database.
+ *
+ * RC-3 fix (incident 2026-05-11): Replaced hardcoded project-relative
+ * "migrations/supabase/" string with runtime-resolved absolute path to
+ * the bundled SQL files inside this package.
  */
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
 import { makeToolResponse, makeErrorResponse } from '../shared.js';
+const PACKAGE_MIGRATIONS_SUPABASE = join(dirname(fileURLToPath(import.meta.url)), '..', '..', '..', 'migrations', 'supabase');
+const PACKAGE_MIGRATIONS_POCKETBASE = join(dirname(fileURLToPath(import.meta.url)), '..', '..', '..', 'migrations', 'pocketbase');
 /** Collection schemas for PocketBase creation */
 const COLLECTION_SCHEMAS = [
     { name: 'knowledge', description: 'Knowledge items (facts, patterns, insights, lessons, references)' },
@@ -23,10 +31,11 @@ const COLLECTION_SCHEMAS = [
     { name: 'affiliates', description: 'Affiliate partners and commissions' },
 ];
 export function registerSetupMigrate(server, adapter) {
-    server.tool('setup_migrate', 'Create missing database collections/tables. Additive only — existing collections are skipped. For PocketBase, creates collections via API. For Supabase, reports SQL migrations to run manually.', {}, async () => {
+    server.tool('setup_migrate', 'Create missing database collections/tables. Additive only — existing collections are skipped. For PocketBase, creates collections via API. For Supabase, reports SQL migrations and recommends running setup_bootstrap for paste-ready SQL.', {}, async () => {
         try {
             const skipped = [];
             const needsMigration = [];
+            const migrationsPath = adapter.backend === 'supabase' ? PACKAGE_MIGRATIONS_SUPABASE : PACKAGE_MIGRATIONS_POCKETBASE;
             for (const schema of COLLECTION_SCHEMAS) {
                 try {
                     const exists = await adapter.collectionExists(schema.name);
@@ -34,18 +43,12 @@ export function registerSetupMigrate(server, adapter) {
                         skipped.push(schema.name);
                         continue;
                     }
-                    if (adapter.backend === 'supabase') {
-                        needsMigration.push({
-                            name: schema.name,
-                            instruction: 'Run SQL migrations from migrations/supabase/ directory.',
-                        });
-                    }
-                    else {
-                        needsMigration.push({
-                            name: schema.name,
-                            instruction: 'Run PocketBase migrations from migrations/pocketbase/ directory.',
-                        });
-                    }
+                    needsMigration.push({
+                        name: schema.name,
+                        instruction: adapter.backend === 'supabase'
+                            ? `Apply SQL from ${migrationsPath}/. Easiest path: call setup_bootstrap for a paste-ready SQL block.`
+                            : `Apply migration from ${migrationsPath}/.`,
+                    });
                 }
                 catch (err) {
                     const msg = err instanceof Error ? err.message : 'Unknown error';
@@ -55,6 +58,7 @@ export function registerSetupMigrate(server, adapter) {
             }
             return makeToolResponse({
                 backend: adapter.backend,
+                migrations_path: migrationsPath,
                 existing: skipped.length,
                 needs_migration: needsMigration.length,
                 details: {
@@ -62,8 +66,8 @@ export function registerSetupMigrate(server, adapter) {
                     needs_migration: needsMigration.length > 0 ? needsMigration : undefined,
                 },
                 message: adapter.backend === 'pocketbase'
-                    ? `Schema check complete. ${skipped.length} existing, ${needsMigration.length} need migration files. Run PocketBase migrations from migrations/pocketbase/ directory.`
-                    : `Schema check complete. ${skipped.length} existing, ${needsMigration.length} need SQL migrations. Apply migrations from migrations/supabase/ directory.`,
+                    ? `Schema check complete. ${skipped.length} existing, ${needsMigration.length} need migration files. Apply from ${migrationsPath}/.`
+                    : `Schema check complete. ${skipped.length} existing, ${needsMigration.length} need SQL. Run setup_bootstrap for a paste-ready block, or apply from ${migrationsPath}/ manually.`,
             });
         }
         catch (error) {
@@ -72,4 +76,4 @@ export function registerSetupMigrate(server, adapter) {
         }
     });
 }
-//# sourceMappingURL=setup-migrate.js.map
+//# sourceMappingURL=setup-migrate.js.map

package/dist/tools/setup/setup-status.js

@@ -2,6 +2,13 @@
  * Tool: setup_status
  *
  * Check backend connection, list existing/missing collections, report status.
+ *
+ * RC-1 fix (incident 2026-05-11): Previously called adapter.listCollections()
+ * which uses rpc('get_public_tables') — a custom Postgres function absent from
+ * fresh Supabase projects. Fallback to information_schema also failed because
+ * PostgREST only exposes the public schema. Now uses the same code path as
+ * setup_migrate (adapter.collectionExists per expected collection) so the
+ * diagnostic agrees with the data tools.
  */
 import { makeToolResponse, makeErrorResponse } from '../shared.js';
 const EXPECTED_COLLECTIONS = [
@@ -23,20 +30,18 @@ const EXPECTED_COLLECTIONS = [
 export function registerSetupStatus(server, adapter) {
     server.tool('setup_status', 'Check database connection status, list existing and missing collections, and report schema readiness.', {}, { readOnlyHint: true }, async () => {
         try {
-            // Test connection by listing collections
-            const existing = await adapter.listCollections();
-            const existingSet = new Set(existing);
             const present = [];
             const missing = [];
             for (const collection of EXPECTED_COLLECTIONS) {
-                if (existingSet.has(collection)) {
+                const exists = await adapter.collectionExists(collection);
+                if (exists) {
                     present.push(collection);
                 }
                 else {
                     missing.push(collection);
                 }
             }
-            // Check for settings table and schema version
+            const existingSet = new Set(present);
             let schemaVersion = null;
             if (existingSet.has('settings')) {
                 try {
@@ -75,4 +80,4 @@ export function registerSetupStatus(server, adapter) {
         }
     });
 }
-//# sourceMappingURL=setup-status.js.map
+//# sourceMappingURL=setup-status.js.map

package/migrations/pocketbase/001_core_schema.js

@@ -2,26 +2,24 @@
  * PocketBase Migration 001: Core schema
  *
  * Creates knowledge, decisions, sessions collections.
- * PocketBase v0.23+ field format.
  */
 
 /// <reference path="../pb_data/types.d.ts" />
 
 migrate((app) => {
+  // knowledge collection
   const knowledge = new Collection({
     name: 'knowledge',
     type: 'base',
-    fields: [
-      { name: 'type', type: 'select', required: true, maxSelect: 1, values: ['fact', 'knowledge', 'pattern', 'insight', 'lesson', 'reference'] },
-      { name: 'title', type: 'text', required: true, max: 500 },
-      { name: 'content', type: 'editor', required: true, maxSize: 50000 },
-      { name: 'summary', type: 'text', max: 2000 },
+    schema: [
+      { name: 'type', type: 'select', required: true, options: { values: ['fact', 'knowledge', 'pattern', 'insight', 'lesson', 'reference'] } },
+      { name: 'title', type: 'text', required: true, options: { maxSize: 500 } },
+      { name: 'content', type: 'editor', required: true, options: { maxSize: 50000 } },
+      { name: 'summary', type: 'text', options: { maxSize: 2000 } },
       { name: 'tags', type: 'json' },
-      { name: 'source', type: 'text', max: 500 },
-      { name: 'confidence', type: 'number', min: 0, max: 1 },
+      { name: 'source', type: 'text', options: { maxSize: 500 } },
+      { name: 'confidence', type: 'number', options: { min: 0, max: 1 } },
       { name: 'last_validated_at', type: 'date' },
-      { name: 'created', type: 'autodate', onCreate: true },
-      { name: 'updated', type: 'autodate', onCreate: true, onUpdate: true },
     ],
     indexes: [
       'CREATE INDEX idx_knowledge_type ON knowledge (type)',
@@ -30,47 +28,45 @@ migrate((app) => {
   });
   app.save(knowledge);
 
+  // decisions collection
   const decisions = new Collection({
     name: 'decisions',
     type: 'base',
-    fields: [
-      { name: 'title', type: 'text', required: true, max: 500 },
-      { name: 'context', type: 'editor', maxSize: 5000 },
+    schema: [
+      { name: 'title', type: 'text', required: true, options: { maxSize: 500 } },
+      { name: 'context', type: 'editor', options: { maxSize: 5000 } },
       { name: 'options_considered', type: 'json', required: true },
-      { name: 'chosen_option', type: 'text', required: true, max: 500 },
-      { name: 'rationale', type: 'editor', maxSize: 5000 },
-      { name: 'outcome', type: 'editor', maxSize: 5000 },
+      { name: 'chosen_option', type: 'text', required: true, options: { maxSize: 500 } },
+      { name: 'rationale', type: 'editor', options: { maxSize: 5000 } },
+      { name: 'outcome', type: 'editor', options: { maxSize: 5000 } },
       { name: 'tags', type: 'json' },
-      { name: 'created', type: 'autodate', onCreate: true },
-      { name: 'updated', type: 'autodate', onCreate: true, onUpdate: true },
     ],
   });
   app.save(decisions);
 
+  // sessions collection
   const sessions = new Collection({
     name: 'sessions',
     type: 'base',
-    fields: [
-      { name: 'title', type: 'text', required: true, max: 500 },
-      { name: 'summary', type: 'editor', required: true, maxSize: 10000 },
+    schema: [
+      { name: 'title', type: 'text', required: true, options: { maxSize: 500 } },
+      { name: 'summary', type: 'editor', required: true, options: { maxSize: 10000 } },
       { name: 'session_date', type: 'date' },
       { name: 'skills_used', type: 'json' },
       { name: 'files_changed', type: 'json' },
       { name: 'decisions_made', type: 'json' },
       { name: 'duration_minutes', type: 'number' },
-      { name: 'task_id', type: 'text', max: 100 },
-      { name: 'branch', type: 'text', max: 200 },
+      { name: 'task_id', type: 'text', options: { maxSize: 100 } },
+      { name: 'branch', type: 'text', options: { maxSize: 200 } },
       { name: 'patterns_learned', type: 'json' },
       { name: 'knowledge_created', type: 'number' },
       { name: 'knowledge_updated', type: 'number' },
       { name: 'metadata', type: 'json' },
-      { name: 'created', type: 'autodate', onCreate: true },
-      { name: 'updated', type: 'autodate', onCreate: true, onUpdate: true },
     ],
   });
   app.save(sessions);
 }, (app) => {
-  const c1 = app.findCollectionByNameOrId('sessions'); if (c1) app.delete(c1);
-  const c2 = app.findCollectionByNameOrId('decisions'); if (c2) app.delete(c2);
-  const c3 = app.findCollectionByNameOrId('knowledge'); if (c3) app.delete(c3);
+  app.delete(app.findCollectionByNameOrId('sessions'));
+  app.delete(app.findCollectionByNameOrId('decisions'));
+  app.delete(app.findCollectionByNameOrId('knowledge'));
 });

package/migrations/pocketbase/002_goals_tasks.js

@@ -1,23 +1,21 @@
 /**
  * PocketBase Migration 002: Goals and tasks
- * PocketBase v0.23+ field format.
  */
 
 /// <reference path="../pb_data/types.d.ts" />
 
 migrate((app) => {
+  // goals collection
   const goals = new Collection({
     name: 'goals',
     type: 'base',
-    fields: [
-      { name: 'title', type: 'text', required: true, max: 500 },
-      { name: 'description', type: 'editor', maxSize: 5000 },
-      { name: 'timeframe', type: 'select', required: true, maxSelect: 1, values: ['daily', 'weekly', 'monthly', 'quarterly', 'yearly'] },
-      { name: 'status', type: 'select', required: true, maxSelect: 1, values: ['active', 'completed', 'paused', 'abandoned'] },
+    schema: [
+      { name: 'title', type: 'text', required: true, options: { maxSize: 500 } },
+      { name: 'description', type: 'editor', options: { maxSize: 5000 } },
+      { name: 'timeframe', type: 'select', required: true, options: { values: ['daily', 'weekly', 'monthly', 'quarterly', 'yearly'] } },
+      { name: 'status', type: 'select', required: true, options: { values: ['active', 'completed', 'paused', 'abandoned'] } },
       { name: 'key_results', type: 'json' },
       { name: 'tags', type: 'json' },
-      { name: 'created', type: 'autodate', onCreate: true },
-      { name: 'updated', type: 'autodate', onCreate: true, onUpdate: true },
     ],
     indexes: [
       'CREATE INDEX idx_goals_status ON goals (status)',
@@ -26,19 +24,18 @@ migrate((app) => {
   });
   app.save(goals);
 
+  // tasks collection
   const tasks = new Collection({
     name: 'tasks',
     type: 'base',
-    fields: [
-      { name: 'title', type: 'text', required: true, max: 500 },
-      { name: 'description', type: 'editor', maxSize: 5000 },
-      { name: 'status', type: 'select', required: true, maxSelect: 1, values: ['todo', 'in_progress', 'done', 'cancelled'] },
-      { name: 'priority', type: 'select', required: true, maxSelect: 1, values: ['low', 'medium', 'high', 'urgent'] },
+    schema: [
+      { name: 'title', type: 'text', required: true, options: { maxSize: 500 } },
+      { name: 'description', type: 'editor', options: { maxSize: 5000 } },
+      { name: 'status', type: 'select', required: true, options: { values: ['todo', 'in_progress', 'done', 'cancelled'] } },
+      { name: 'priority', type: 'select', required: true, options: { values: ['low', 'medium', 'high', 'urgent'] } },
       { name: 'due_date', type: 'date' },
       { name: 'tags', type: 'json' },
-      { name: 'goal_id', type: 'text', max: 100 },
-      { name: 'created', type: 'autodate', onCreate: true },
-      { name: 'updated', type: 'autodate', onCreate: true, onUpdate: true },
+      { name: 'goal_id', type: 'text', options: { maxSize: 100 } },
     ],
     indexes: [
       'CREATE INDEX idx_tasks_status ON tasks (status)',
@@ -47,6 +44,6 @@ migrate((app) => {
   });
   app.save(tasks);
 }, (app) => {
-  const t = app.findCollectionByNameOrId('tasks'); if (t) app.delete(t);
-  const g = app.findCollectionByNameOrId('goals'); if (g) app.delete(g);
+  app.delete(app.findCollectionByNameOrId('tasks'));
+  app.delete(app.findCollectionByNameOrId('goals'));
 });

package/migrations/pocketbase/003_contacts.js

@@ -1,6 +1,5 @@
 /**
  * PocketBase Migration 003: Contacts
- * PocketBase v0.23+ field format.
  */
 
 /// <reference path="../pb_data/types.d.ts" />
@@ -9,18 +8,16 @@ migrate((app) => {
   const contacts = new Collection({
     name: 'contacts',
     type: 'base',
-    fields: [
-      { name: 'name', type: 'text', required: true, max: 200 },
-      { name: 'company', type: 'text', max: 200 },
-      { name: 'role', type: 'text', max: 200 },
-      { name: 'email', type: 'email' },
-      { name: 'phone', type: 'text', max: 50 },
-      { name: 'relationship', type: 'select', maxSelect: 1, values: ['colleague', 'client', 'prospect', 'partner', 'other'] },
-      { name: 'notes', type: 'editor', maxSize: 5000 },
+    schema: [
+      { name: 'name', type: 'text', required: true, options: { maxSize: 200 } },
+      { name: 'company', type: 'text', options: { maxSize: 200 } },
+      { name: 'role', type: 'text', options: { maxSize: 200 } },
+      { name: 'email', type: 'email', options: { maxSize: 200 } },
+      { name: 'phone', type: 'text', options: { maxSize: 50 } },
+      { name: 'relationship', type: 'select', options: { values: ['colleague', 'client', 'prospect', 'partner', 'other'] } },
+      { name: 'notes', type: 'editor', options: { maxSize: 5000 } },
       { name: 'tags', type: 'json' },
       { name: 'last_contact_date', type: 'date' },
-      { name: 'created', type: 'autodate', onCreate: true },
-      { name: 'updated', type: 'autodate', onCreate: true, onUpdate: true },
     ],
     indexes: [
       'CREATE INDEX idx_contacts_name ON contacts (name)',
@@ -28,5 +25,5 @@ migrate((app) => {
   });
   app.save(contacts);
 }, (app) => {
-  const c = app.findCollectionByNameOrId('contacts'); if (c) app.delete(c);
+  app.delete(app.findCollectionByNameOrId('contacts'));
 });

package/migrations/pocketbase/004_entity_aliases.js

@@ -1,19 +1,17 @@
 /**
  * PocketBase Migration 004: Entity aliases + settings
- * PocketBase v0.23+ field format.
  */
 
 /// <reference path="../pb_data/types.d.ts" />
 
 migrate((app) => {
+  // entity_aliases collection
   const aliases = new Collection({
     name: 'entity_aliases',
     type: 'base',
-    fields: [
-      { name: 'canonical', type: 'text', required: true, max: 100 },
-      { name: 'alias', type: 'text', required: true, max: 200 },
-      { name: 'created', type: 'autodate', onCreate: true },
-      { name: 'updated', type: 'autodate', onCreate: true, onUpdate: true },
+    schema: [
+      { name: 'canonical', type: 'text', required: true, options: { maxSize: 100 } },
+      { name: 'alias', type: 'text', required: true, options: { maxSize: 200 } },
     ],
     indexes: [
       'CREATE UNIQUE INDEX idx_entity_aliases_unique ON entity_aliases (canonical, alias)',
@@ -23,14 +21,13 @@ migrate((app) => {
   });
   app.save(aliases);
 
+  // settings collection
   const settings = new Collection({
     name: 'settings',
     type: 'base',
-    fields: [
-      { name: 'key', type: 'text', required: true, max: 100 },
+    schema: [
+      { name: 'key', type: 'text', required: true, options: { maxSize: 100 } },
       { name: 'value', type: 'editor' },
-      { name: 'created', type: 'autodate', onCreate: true },
-      { name: 'updated', type: 'autodate', onCreate: true, onUpdate: true },
     ],
     indexes: [
       'CREATE UNIQUE INDEX idx_settings_key ON settings (key)',
@@ -38,6 +35,6 @@ migrate((app) => {
   });
   app.save(settings);
 }, (app) => {
-  const s = app.findCollectionByNameOrId('settings'); if (s) app.delete(s);
-  const a = app.findCollectionByNameOrId('entity_aliases'); if (a) app.delete(a);
+  app.delete(app.findCollectionByNameOrId('settings'));
+  app.delete(app.findCollectionByNameOrId('entity_aliases'));
 });

package/migrations/pocketbase/005_prospects.js

@@ -1,6 +1,5 @@
 /**
  * PocketBase Migration 005: Prospects (CRM)
- * PocketBase v0.23+ field format.
  */
 
 /// <reference path="../pb_data/types.d.ts" />
@@ -9,22 +8,20 @@ migrate((app) => {
   const prospects = new Collection({
     name: 'prospects',
     type: 'base',
-    fields: [
-      { name: 'name', type: 'text', required: true, max: 200 },
-      { name: 'email', type: 'email' },
-      { name: 'company', type: 'text', max: 200 },
-      { name: 'role', type: 'text', max: 200 },
-      { name: 'stage', type: 'select', required: true, maxSelect: 1, values: ['new', 'contacted', 'responded', 'interested', 'ready_to_buy', 'proposal_sent', 'negotiating', 'closed_won', 'closed_lost', 'nurturing'] },
-      { name: 'source', type: 'text', max: 200 },
+    schema: [
+      { name: 'name', type: 'text', required: true, options: { maxSize: 200 } },
+      { name: 'email', type: 'email', options: { maxSize: 200 } },
+      { name: 'company', type: 'text', options: { maxSize: 200 } },
+      { name: 'role', type: 'text', options: { maxSize: 200 } },
+      { name: 'stage', type: 'select', required: true, options: { values: ['new', 'contacted', 'responded', 'interested', 'ready_to_buy', 'proposal_sent', 'negotiating', 'closed_won', 'closed_lost', 'nurturing'] } },
+      { name: 'source', type: 'text', options: { maxSize: 200 } },
       { name: 'estimated_value', type: 'number' },
-      { name: 'next_action_type', type: 'text', max: 100 },
+      { name: 'next_action_type', type: 'text', options: { maxSize: 100 } },
       { name: 'next_followup_date', type: 'date' },
       { name: 'last_contact_date', type: 'date' },
-      { name: 'notes', type: 'editor', maxSize: 10000 },
+      { name: 'notes', type: 'editor', options: { maxSize: 10000 } },
       { name: 'tags', type: 'json' },
-      { name: 'linkedin_url', type: 'url' },
-      { name: 'created', type: 'autodate', onCreate: true },
-      { name: 'updated', type: 'autodate', onCreate: true, onUpdate: true },
+      { name: 'linkedin_url', type: 'url', options: { maxSize: 500 } },
     ],
     indexes: [
       'CREATE INDEX idx_prospects_stage ON prospects (stage)',
@@ -32,5 +29,5 @@ migrate((app) => {
   });
   app.save(prospects);
 }, (app) => {
-  const p = app.findCollectionByNameOrId('prospects'); if (p) app.delete(p);
+  app.delete(app.findCollectionByNameOrId('prospects'));
 });

package/migrations/pocketbase/006_business.js

@@ -1,27 +1,25 @@
 /**
  * PocketBase Migration 006: Business collections (blog, email, content)
- * PocketBase v0.23+ field format.
  */
 
 /// <reference path="../pb_data/types.d.ts" />
 
 migrate((app) => {
+  // blog_posts collection
   const blogPosts = new Collection({
     name: 'blog_posts',
     type: 'base',
-    fields: [
-      { name: 'title', type: 'text', required: true, max: 500 },
-      { name: 'slug', type: 'text', required: true, max: 200 },
+    schema: [
+      { name: 'title', type: 'text', required: true, options: { maxSize: 500 } },
+      { name: 'slug', type: 'text', required: true, options: { maxSize: 200 } },
       { name: 'content', type: 'editor', required: true },
-      { name: 'excerpt', type: 'text', max: 500 },
-      { name: 'status', type: 'select', required: true, maxSelect: 1, values: ['draft', 'published', 'archived'] },
+      { name: 'excerpt', type: 'text', options: { maxSize: 500 } },
+      { name: 'status', type: 'select', required: true, options: { values: ['draft', 'published', 'archived'] } },
       { name: 'published_at', type: 'date' },
       { name: 'tags', type: 'json' },
-      { name: 'seo_title', type: 'text', max: 200 },
-      { name: 'seo_description', type: 'text', max: 300 },
-      { name: 'og_image_url', type: 'url' },
-      { name: 'created', type: 'autodate', onCreate: true },
-      { name: 'updated', type: 'autodate', onCreate: true, onUpdate: true },
+      { name: 'seo_title', type: 'text', options: { maxSize: 200 } },
+      { name: 'seo_description', type: 'text', options: { maxSize: 300 } },
+      { name: 'og_image_url', type: 'url', options: { maxSize: 500 } },
     ],
     indexes: [
       'CREATE UNIQUE INDEX idx_blog_posts_slug ON blog_posts (slug)',
@@ -30,25 +28,24 @@ migrate((app) => {
   });
   app.save(blogPosts);
 
+  // email_queue collection
   const emailQueue = new Collection({
     name: 'email_queue',
     type: 'base',
-    fields: [
-      { name: 'to_email', type: 'email', required: true },
-      { name: 'to_name', type: 'text', max: 200 },
-      { name: 'subject', type: 'text', required: true, max: 500 },
+    schema: [
+      { name: 'to_email', type: 'email', required: true, options: { maxSize: 200 } },
+      { name: 'to_name', type: 'text', options: { maxSize: 200 } },
+      { name: 'subject', type: 'text', required: true, options: { maxSize: 500 } },
       { name: 'body_html', type: 'editor', required: true },
       { name: 'body_text', type: 'editor' },
-      { name: 'status', type: 'select', required: true, maxSelect: 1, values: ['queued', 'sent', 'failed', 'bounced'] },
-      { name: 'sequence_id', type: 'text', max: 100 },
+      { name: 'status', type: 'select', required: true, options: { values: ['queued', 'sent', 'failed', 'bounced'] } },
+      { name: 'sequence_id', type: 'text', options: { maxSize: 100 } },
       { name: 'sequence_step', type: 'number' },
-      { name: 'prospect_id', type: 'text', max: 100 },
+      { name: 'prospect_id', type: 'text', options: { maxSize: 100 } },
       { name: 'scheduled_at', type: 'date' },
       { name: 'sent_at', type: 'date' },
       { name: 'error', type: 'editor' },
-      { name: 'resend_id', type: 'text', max: 200 },
-      { name: 'created', type: 'autodate', onCreate: true },
-      { name: 'updated', type: 'autodate', onCreate: true, onUpdate: true },
+      { name: 'resend_id', type: 'text', options: { maxSize: 200 } },
     ],
     indexes: [
       'CREATE INDEX idx_email_queue_status ON email_queue (status)',
@@ -56,20 +53,19 @@ migrate((app) => {
   });
   app.save(emailQueue);
 
+  // content_calendar collection
   const contentCalendar = new Collection({
     name: 'content_calendar',
     type: 'base',
-    fields: [
-      { name: 'title', type: 'text', required: true, max: 500 },
+    schema: [
+      { name: 'title', type: 'text', required: true, options: { maxSize: 500 } },
       { name: 'content', type: 'editor' },
-      { name: 'platform', type: 'select', required: true, maxSelect: 1, values: ['linkedin', 'newsletter', 'blog', 'twitter', 'other'] },
-      { name: 'pillar', type: 'text', max: 100 },
-      { name: 'status', type: 'select', required: true, maxSelect: 1, values: ['idea', 'drafting', 'ready', 'published'] },
+      { name: 'platform', type: 'select', required: true, options: { values: ['linkedin', 'newsletter', 'blog', 'twitter', 'other'] } },
+      { name: 'pillar', type: 'text', options: { maxSize: 100 } },
+      { name: 'status', type: 'select', required: true, options: { values: ['idea', 'drafting', 'ready', 'published'] } },
       { name: 'scheduled_date', type: 'date' },
-      { name: 'published_url', type: 'url' },
-      { name: 'persona', type: 'text', max: 100 },
-      { name: 'created', type: 'autodate', onCreate: true },
-      { name: 'updated', type: 'autodate', onCreate: true, onUpdate: true },
+      { name: 'published_url', type: 'url', options: { maxSize: 500 } },
+      { name: 'persona', type: 'text', options: { maxSize: 100 } },
     ],
     indexes: [
       'CREATE INDEX idx_content_calendar_platform ON content_calendar (platform)',
@@ -78,7 +74,7 @@ migrate((app) => {
   });
   app.save(contentCalendar);
 }, (app) => {
-  const cc = app.findCollectionByNameOrId('content_calendar'); if (cc) app.delete(cc);
-  const eq = app.findCollectionByNameOrId('email_queue'); if (eq) app.delete(eq);
-  const bp = app.findCollectionByNameOrId('blog_posts'); if (bp) app.delete(bp);
+  app.delete(app.findCollectionByNameOrId('content_calendar'));
+  app.delete(app.findCollectionByNameOrId('email_queue'));
+  app.delete(app.findCollectionByNameOrId('blog_posts'));
 });

package/migrations/pocketbase/007_newsletter_affiliates.js

@@ -1,24 +1,22 @@
 /**
  * PocketBase Migration 007: Newsletter subscribers and affiliates
- * PocketBase v0.23+ field format.
  */
 
 /// <reference path="../pb_data/types.d.ts" />
 
 migrate((app) => {
+  // newsletter_subscribers collection
   const subscribers = new Collection({
     name: 'newsletter_subscribers',
     type: 'base',
-    fields: [
-      { name: 'email', type: 'email', required: true },
-      { name: 'name', type: 'text', max: 200 },
-      { name: 'status', type: 'select', required: true, maxSelect: 1, values: ['active', 'unsubscribed', 'bounced'] },
-      { name: 'source', type: 'text', max: 200 },
+    schema: [
+      { name: 'email', type: 'email', required: true, options: { maxSize: 200 } },
+      { name: 'name', type: 'text', options: { maxSize: 200 } },
+      { name: 'status', type: 'select', required: true, options: { values: ['active', 'unsubscribed', 'bounced'] } },
+      { name: 'source', type: 'text', options: { maxSize: 200 } },
       { name: 'tags', type: 'json' },
       { name: 'subscribed_at', type: 'date' },
       { name: 'unsubscribed_at', type: 'date' },
-      { name: 'created', type: 'autodate', onCreate: true },
-      { name: 'updated', type: 'autodate', onCreate: true, onUpdate: true },
     ],
     indexes: [
       'CREATE UNIQUE INDEX idx_newsletter_subscribers_email ON newsletter_subscribers (email)',
@@ -26,20 +24,19 @@ migrate((app) => {
   });
   app.save(subscribers);
 
+  // affiliates collection
   const affiliates = new Collection({
     name: 'affiliates',
     type: 'base',
-    fields: [
-      { name: 'name', type: 'text', required: true, max: 200 },
-      { name: 'email', type: 'email', required: true },
-      { name: 'code', type: 'text', required: true, max: 100 },
-      { name: 'commission_rate', type: 'number', min: 0, max: 1 },
-      { name: 'status', type: 'select', required: true, maxSelect: 1, values: ['pending', 'active', 'paused', 'terminated'] },
+    schema: [
+      { name: 'name', type: 'text', required: true, options: { maxSize: 200 } },
+      { name: 'email', type: 'email', required: true, options: { maxSize: 200 } },
+      { name: 'code', type: 'text', required: true, options: { maxSize: 100 } },
+      { name: 'commission_rate', type: 'number', options: { min: 0, max: 1 } },
+      { name: 'status', type: 'select', required: true, options: { values: ['pending', 'active', 'paused', 'terminated'] } },
       { name: 'total_earned_cents', type: 'number' },
       { name: 'total_paid_cents', type: 'number' },
-      { name: 'stripe_account_id', type: 'text', max: 200 },
-      { name: 'created', type: 'autodate', onCreate: true },
-      { name: 'updated', type: 'autodate', onCreate: true, onUpdate: true },
+      { name: 'stripe_account_id', type: 'text', options: { maxSize: 200 } },
     ],
     indexes: [
       'CREATE UNIQUE INDEX idx_affiliates_email ON affiliates (email)',
@@ -48,6 +45,6 @@ migrate((app) => {
   });
   app.save(affiliates);
 }, (app) => {
-  const a = app.findCollectionByNameOrId('affiliates'); if (a) app.delete(a);
-  const s = app.findCollectionByNameOrId('newsletter_subscribers'); if (s) app.delete(s);
+  app.delete(app.findCollectionByNameOrId('affiliates'));
+  app.delete(app.findCollectionByNameOrId('newsletter_subscribers'));
 });

package/migrations/pocketbase/008_knowledge_links.js

@@ -1,41 +1,38 @@
 /**
- * PocketBase Migration 008: knowledge_links collection
+ * PocketBase migration: knowledge_links collection
  *
- * Typed relationships between MemoryOS entities.
- * PocketBase does not support pgvector — link suggestions use keyword-based
- * text search fallback.
+ * Creates the knowledge_links collection for typed relationships
+ * between MemoryOS entities.
  *
- * PocketBase v0.23+ field format + native migrate() form
- * (was previously module.exports — goja runtime panics on that).
+ * Note: PocketBase does not support pgvector.
+ * Link suggestions use keyword-based text search fallback.
  */
-
-/// <reference path="../pb_data/types.d.ts" />
-
-migrate((app) => {
-  const links = new Collection({
-    name: 'knowledge_links',
-    type: 'base',
-    fields: [
-      { name: 'owner_id', type: 'text', max: 100 },
-      { name: 'source_type', type: 'text', required: true, max: 50 },
-      { name: 'source_id', type: 'text', required: true, max: 36 },
-      { name: 'target_type', type: 'text', required: true, max: 50 },
-      { name: 'target_id', type: 'text', required: true, max: 36 },
-      { name: 'relation_type', type: 'text', required: true, max: 50 },
-      { name: 'confidence', type: 'number', min: 0, max: 1 },
-      { name: 'notes', type: 'text', max: 500 },
-      { name: 'auto_suggested', type: 'bool' },
-      { name: 'created', type: 'autodate', onCreate: true },
-      { name: 'updated', type: 'autodate', onCreate: true, onUpdate: true },
-    ],
-    indexes: [
-      'CREATE INDEX idx_kl_source ON knowledge_links (owner_id, source_type, source_id)',
-      'CREATE INDEX idx_kl_target ON knowledge_links (owner_id, target_type, target_id)',
-      'CREATE UNIQUE INDEX idx_kl_unique ON knowledge_links (owner_id, source_type, source_id, target_type, target_id, relation_type)',
-    ],
-  });
-  app.save(links);
-}, (app) => {
-  const links = app.findCollectionByNameOrId('knowledge_links');
-  if (links) app.delete(links);
-});
+module.exports = {
+    async up(db) {
+        const collection = new Collection({
+            name: 'knowledge_links',
+            type: 'base',
+            schema: [
+                { name: 'owner_id', type: 'text', required: true, options: { maxSize: 100 } },
+                { name: 'source_type', type: 'text', required: true, options: { maxSize: 50 } },
+                { name: 'source_id', type: 'text', required: true, options: { maxSize: 36 } },
+                { name: 'target_type', type: 'text', required: true, options: { maxSize: 50 } },
+                { name: 'target_id', type: 'text', required: true, options: { maxSize: 36 } },
+                { name: 'relation_type', type: 'text', required: true, options: { maxSize: 50 } },
+                { name: 'confidence', type: 'number', options: { min: 0, max: 1 } },
+                { name: 'notes', type: 'text', options: { maxSize: 500 } },
+                { name: 'auto_suggested', type: 'bool' },
+            ],
+            indexes: [
+                'CREATE INDEX idx_kl_source ON knowledge_links (owner_id, source_type, source_id)',
+                'CREATE INDEX idx_kl_target ON knowledge_links (owner_id, target_type, target_id)',
+                'CREATE UNIQUE INDEX idx_kl_unique ON knowledge_links (owner_id, source_type, source_id, target_type, target_id, relation_type)',
+            ],
+        });
+        return db.save(collection);
+    },
+    async down(db) {
+        const collection = await db.findCollectionByNameOrId('knowledge_links');
+        return db.delete(collection);
+    },
+};

package/migrations/supabase/009_align_to_production.sql

@@ -8,14 +8,12 @@
 -- 5. Add decisions-specific columns: rationale, outcome_rating, session_id
 -- 6. Make decisions.options_considered nullable (production data shows this)
 -- 7. Make goals.timeframe nullable (not always known at creation time)
---
--- Each `text[] -> jsonb` conversion must DROP DEFAULT first, change TYPE, then
--- SET a jsonb DEFAULT. Postgres cannot auto-cast the text[] default '{}' to jsonb.
 
 -- === KNOWLEDGE ===
-ALTER TABLE knowledge ALTER COLUMN tags DROP DEFAULT;
+-- Convert tags from text[] to jsonb
 ALTER TABLE knowledge ALTER COLUMN tags TYPE jsonb USING to_jsonb(tags);
 ALTER TABLE knowledge ALTER COLUMN tags SET DEFAULT '[]'::jsonb;
+-- Add missing columns
 ALTER TABLE knowledge ADD COLUMN IF NOT EXISTS owner_id text NOT NULL DEFAULT 'default';
 ALTER TABLE knowledge ADD COLUMN IF NOT EXISTS metadata jsonb DEFAULT '{}'::jsonb;
 ALTER TABLE knowledge ADD COLUMN IF NOT EXISTS source_file text;
@@ -23,13 +21,14 @@ ALTER TABLE knowledge ADD COLUMN IF NOT EXISTS decay_score numeric;
 ALTER TABLE knowledge ADD COLUMN IF NOT EXISTS triggers jsonb;
 
 -- === DECISIONS ===
-ALTER TABLE decisions ALTER COLUMN options_considered DROP DEFAULT;
+-- Convert options_considered from text[] to jsonb
 ALTER TABLE decisions ALTER COLUMN options_considered TYPE jsonb USING to_jsonb(options_considered);
 ALTER TABLE decisions ALTER COLUMN options_considered DROP NOT NULL;
 ALTER TABLE decisions ALTER COLUMN options_considered SET DEFAULT '[]'::jsonb;
-ALTER TABLE decisions ALTER COLUMN tags DROP DEFAULT;
+-- Convert tags from text[] to jsonb
 ALTER TABLE decisions ALTER COLUMN tags TYPE jsonb USING to_jsonb(tags);
 ALTER TABLE decisions ALTER COLUMN tags SET DEFAULT '[]'::jsonb;
+-- Add missing columns
 ALTER TABLE decisions ADD COLUMN IF NOT EXISTS owner_id text NOT NULL DEFAULT 'default';
 ALTER TABLE decisions ADD COLUMN IF NOT EXISTS metadata jsonb DEFAULT '{}'::jsonb;
 ALTER TABLE decisions ADD COLUMN IF NOT EXISTS rationale text;
@@ -37,33 +36,37 @@ ALTER TABLE decisions ADD COLUMN IF NOT EXISTS outcome_rating text;
 ALTER TABLE decisions ADD COLUMN IF NOT EXISTS session_id uuid;
 
 -- === SESSIONS ===
-ALTER TABLE sessions ALTER COLUMN skills_used DROP DEFAULT;
+-- Convert skills_used, files_changed from text[] to jsonb
 ALTER TABLE sessions ALTER COLUMN skills_used TYPE jsonb USING to_jsonb(skills_used);
 ALTER TABLE sessions ALTER COLUMN skills_used SET DEFAULT '[]'::jsonb;
-ALTER TABLE sessions ALTER COLUMN files_changed DROP DEFAULT;
 ALTER TABLE sessions ALTER COLUMN files_changed TYPE jsonb USING to_jsonb(files_changed);
 ALTER TABLE sessions ALTER COLUMN files_changed SET DEFAULT '[]'::jsonb;
+-- Add missing columns
 ALTER TABLE sessions ADD COLUMN IF NOT EXISTS owner_id text NOT NULL DEFAULT 'default';
 
 -- === GOALS ===
-ALTER TABLE goals ALTER COLUMN tags DROP DEFAULT;
+-- Convert tags from text[] to jsonb
 ALTER TABLE goals ALTER COLUMN tags TYPE jsonb USING to_jsonb(tags);
 ALTER TABLE goals ALTER COLUMN tags SET DEFAULT '[]'::jsonb;
+-- Make timeframe nullable (not always known)
 ALTER TABLE goals ALTER COLUMN timeframe DROP NOT NULL;
+-- Add missing columns
 ALTER TABLE goals ADD COLUMN IF NOT EXISTS owner_id text NOT NULL DEFAULT 'default';
 ALTER TABLE goals ADD COLUMN IF NOT EXISTS metadata jsonb DEFAULT '{}'::jsonb;
 
 -- === TASKS ===
-ALTER TABLE tasks ALTER COLUMN tags DROP DEFAULT;
+-- Convert tags from text[] to jsonb
 ALTER TABLE tasks ALTER COLUMN tags TYPE jsonb USING to_jsonb(tags);
 ALTER TABLE tasks ALTER COLUMN tags SET DEFAULT '[]'::jsonb;
+-- Add missing columns
 ALTER TABLE tasks ADD COLUMN IF NOT EXISTS owner_id text NOT NULL DEFAULT 'default';
 ALTER TABLE tasks ADD COLUMN IF NOT EXISTS metadata jsonb DEFAULT '{}'::jsonb;
 
 -- === CONTACTS ===
-ALTER TABLE contacts ALTER COLUMN tags DROP DEFAULT;
+-- Convert tags from text[] to jsonb
 ALTER TABLE contacts ALTER COLUMN tags TYPE jsonb USING to_jsonb(tags);
 ALTER TABLE contacts ALTER COLUMN tags SET DEFAULT '[]'::jsonb;
+-- Add missing columns
 ALTER TABLE contacts ADD COLUMN IF NOT EXISTS owner_id text NOT NULL DEFAULT 'default';
 ALTER TABLE contacts ADD COLUMN IF NOT EXISTS metadata jsonb DEFAULT '{}'::jsonb;
 ALTER TABLE contacts ADD COLUMN IF NOT EXISTS last_interaction_at timestamptz;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@iwo-szapar/data-mcp",
-  "version": "0.4.0",
+  "version": "0.5.0",
   "description": "Unified data MCP server for Second Brain — PocketBase and Supabase adapters. 40 tools: knowledge, sessions, goals, tasks, contacts, CRM, blog, email, content calendar.",
   "author": "Iwo Szapar <iwo.szapar@gmail.com> (https://iwoszapar.com)",
   "homepage": "https://iwoszapar.com/second-brain-ai",

package/README.md

@@ -1,286 +0,0 @@
-# @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.