@persistadev/mcp-server 3.2.0

package/README.md

@@ -0,0 +1,126 @@
+# @persistadev/mcp-server
+
+> Give your AI persistent memory across sessions
+
+Persista is an MCP (Model Context Protocol) server that provides AI assistants with persistent memory, context management, and intelligent learning capabilities.
+
+## Features
+
+🧠 **Memory** - Save and retrieve user preferences, facts, and behaviors across sessions  
+📝 **Context** - Smart context packing with relevance scoring and threading  
+🔄 **Sync** - Multi-instance coordination with intent broadcasting  
+📚 **Knowledge** - Version-aware best practices and deprecation warnings  
+🧬 **Codebase DNA** - Automatic detection of patterns, conventions, and architecture  
+⚠️ **Error Learning** - Captures build errors and anti-patterns to avoid repeating mistakes  
+
+## Quick Start
+
+### 1. Get an API Key
+
+Sign up at [persista.dev](https://persista.dev) and create an API key from the dashboard.
+
+### 2. Add to Cursor
+
+Add this to your `~/.cursor/mcp.json`:
+
+```json
+{
+  "mcpServers": {
+    "persista": {
+      "command": "npx",
+      "args": ["-y", "@persistadev/mcp-server"],
+      "env": {
+        "PERSISTA_API_KEY": "pst_your_api_key_here"
+      }
+    }
+  }
+}
+```
+
+### 3. Restart Cursor
+
+That's it! Your AI now has persistent memory.
+
+## What It Does
+
+Once installed, the AI can:
+
+- **Remember** your preferences, coding style, and project decisions
+- **Detect** your codebase patterns and conventions automatically
+- **Learn** from errors to avoid making the same mistakes
+- **Track** git changes between sessions
+- **Coordinate** with other AI instances working on the same project
+
+## Environment Variables
+
+| Variable | Required | Description |
+|----------|----------|-------------|
+| `PERSISTA_API_KEY` | Yes | Your API key from persista.dev |
+| `PERSISTA_API_URL` | No | Custom API URL (defaults to api.persista.dev) |
+| `PERSISTA_USER_ID` | No | Custom user ID (defaults to system username) |
+| `PERSISTA_PROJECT_DIR` | No | Override project directory detection |
+
+## Available Tools
+
+The MCP server provides these tools to the AI:
+
+### Memory
+- `memory_save` - Save memories with confidence decay and code attachment
+- `memory_get` - Retrieve all memories with effective confidence scores
+- `memory_search` - Semantic search through memories
+- `memory_for_file` - Get memories attached to specific files
+
+### Context
+- `context_pack` - Smart context packing within token budget
+- `context_relevant` - Get most relevant context for conversation
+- `context_thread_create` - Create conversation threads
+- `context_summary_save` - Save conversation summaries
+
+### Sync
+- `sync_discover` - Find other AI instances on this project
+- `sync_intent` - Broadcast editing intent to prevent conflicts
+- `sync_check_conflicts` - Check for conflicting edits
+
+### Knowledge
+- `knowledge_check` - Version-aware best practices
+- `knowledge_deprecations` - Get deprecation warnings
+- `knowledge_scan_code` - Scan code for deprecated patterns
+- `knowledge_learn_pattern` - Learn custom patterns
+
+### DNA (Codebase Analysis)
+- `dna_analyze` - Deep codebase analysis
+- `dna_conventions` - Get coding conventions
+- `dna_patterns` - Get detected patterns
+- `dna_architecture` - Get architecture info
+- `dna_add_decision` - Record tech decisions
+- `dna_mark_critical` - Mark critical paths
+
+### Error Learning
+- `error_capture` - Capture errors for learning
+- `error_patterns` - Get known error patterns
+
+### Session
+- `session_refresh` - Reload session context
+- `session_summary` - Get full session summary
+
+## Resources
+
+The MCP server also provides these auto-injected resources:
+
+- `persista://session/context` - Full session context (memory, git, DNA)
+- `persista://user/memory` - All user memories
+- `persista://codebase/dna` - Basic codebase analysis
+- `persista://codebase/dna-deep` - Deep codebase DNA
+- `persista://git/changes` - Git changes since last session
+- `persista://knowledge/relevant` - Relevant best practices
+- `persista://errors/learned` - Learned error patterns
+
+## Links
+
+- **Website**: [persista.dev](https://persista.dev)
+- **Dashboard**: [persista.dev/dashboard](https://persista.dev/dashboard)
+- **Docs**: [persista.dev/docs](https://persista.dev/docs)
+
+## License
+
+MIT

package/dist/index-direct.js

@@ -0,0 +1,307 @@
+#!/usr/bin/env node
+"use strict";
+/**
+ * Persista MCP Server - Direct Supabase Version
+ * Connects directly to Supabase instead of Edge Functions
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const index_js_1 = require("@modelcontextprotocol/sdk/server/index.js");
+const stdio_js_1 = require("@modelcontextprotocol/sdk/server/stdio.js");
+const types_js_1 = require("@modelcontextprotocol/sdk/types.js");
+const supabase_js_1 = require("@supabase/supabase-js");
+// Config from environment
+const SUPABASE_URL = process.env.SUPABASE_URL;
+const SUPABASE_KEY = process.env.SUPABASE_KEY; // anon key
+const API_KEY = process.env.PERSISTA_API_KEY;
+const USER_ID = process.env.PERSISTA_USER_ID || 'default';
+if (!SUPABASE_URL || !SUPABASE_KEY) {
+    console.error('Error: SUPABASE_URL and SUPABASE_KEY environment variables are required');
+    process.exit(1);
+}
+if (!API_KEY) {
+    console.error('Error: PERSISTA_API_KEY environment variable is required');
+    process.exit(1);
+}
+const supabase = (0, supabase_js_1.createClient)(SUPABASE_URL, SUPABASE_KEY);
+// Get app_id from API key
+async function getAppId() {
+    const encoder = new TextEncoder();
+    const data = encoder.encode(API_KEY);
+    const hashBuffer = await crypto.subtle.digest('SHA-256', data);
+    const hashArray = Array.from(new Uint8Array(hashBuffer));
+    const apiKeyHash = hashArray.map(b => b.toString(16).padStart(2, '0')).join('');
+    const { data: app } = await supabase
+        .from('apps')
+        .select('id')
+        .eq('api_key_hash', apiKeyHash)
+        .single();
+    return app?.id || null;
+}
+// Get or create user
+async function getOrCreateUser(externalId) {
+    // Try to find existing user
+    const { data: existing } = await supabase
+        .from('users')
+        .select('id')
+        .eq('external_id', externalId)
+        .single();
+    if (existing)
+        return existing.id;
+    // Create new user
+    const { data: newUser } = await supabase
+        .from('users')
+        .insert({ external_id: externalId })
+        .select('id')
+        .single();
+    return newUser?.id || null;
+}
+// Create MCP server
+const server = new index_js_1.Server({ name: 'persista', version: '0.1.0' }, { capabilities: { tools: {} } });
+server.setRequestHandler(types_js_1.ListToolsRequestSchema, async () => {
+    return {
+        tools: [
+            {
+                name: 'memory_save',
+                description: 'Save something about the user to persistent memory. Use this when you learn preferences, facts, decisions, or behaviors.',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        category: {
+                            type: 'string',
+                            enum: ['preference', 'fact', 'project', 'behavior', 'custom'],
+                            description: 'Category: preference, fact, project, behavior, or custom'
+                        },
+                        key: {
+                            type: 'string',
+                            description: 'Unique identifier like "coding_style" or "timezone"'
+                        },
+                        value: {
+                            description: 'The data to store (any JSON)'
+                        }
+                    },
+                    required: ['category', 'key', 'value']
+                }
+            },
+            {
+                name: 'memory_get',
+                description: 'Get all memories about the user. Use at the start of conversations for context.',
+                inputSchema: { type: 'object', properties: {} }
+            },
+            {
+                name: 'memory_forget',
+                description: 'Delete a specific memory by key.',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        key: { type: 'string', description: 'The key to delete' }
+                    },
+                    required: ['key']
+                }
+            },
+            {
+                name: 'project_save',
+                description: 'Save or update information about a project the user is working on.',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        name: { type: 'string', description: 'Project name' },
+                        description: { type: 'string', description: 'What the project is about' },
+                        tech_stack: {
+                            type: 'array',
+                            items: { type: 'string' },
+                            description: 'Technologies used'
+                        },
+                        current_tasks: {
+                            type: 'array',
+                            items: { type: 'string' },
+                            description: 'Current tasks or todos'
+                        }
+                    },
+                    required: ['name']
+                }
+            },
+            {
+                name: 'project_get',
+                description: 'Get the current active project.',
+                inputSchema: { type: 'object', properties: {} }
+            },
+            {
+                name: 'history_save',
+                description: 'Save a summary of the current conversation for future reference.',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        summary: { type: 'string', description: 'Summary of what was discussed' },
+                        key_points: {
+                            type: 'array',
+                            items: { type: 'string' },
+                            description: 'Key points from the conversation'
+                        },
+                        decisions: {
+                            type: 'array',
+                            items: { type: 'string' },
+                            description: 'Decisions that were made'
+                        }
+                    },
+                    required: ['summary']
+                }
+            }
+        ]
+    };
+});
+server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
+    const { name, arguments: args } = request.params;
+    try {
+        const appId = await getAppId();
+        if (!appId) {
+            return { content: [{ type: 'text', text: 'Error: Invalid API key' }], isError: true };
+        }
+        const userId = await getOrCreateUser(USER_ID);
+        if (!userId) {
+            return { content: [{ type: 'text', text: 'Error: Could not get/create user' }], isError: true };
+        }
+        switch (name) {
+            case 'memory_save': {
+                const { category, key, value } = args;
+                // Upsert context
+                const { data, error } = await supabase
+                    .from('user_context')
+                    .upsert({
+                    user_id: userId,
+                    app_id: appId,
+                    category,
+                    key,
+                    value,
+                    source: 'explicit',
+                    confidence: 1.0
+                }, {
+                    onConflict: 'user_id,app_id,category,key'
+                })
+                    .select()
+                    .single();
+                if (error)
+                    throw error;
+                return { content: [{ type: 'text', text: `✅ Saved: ${category}/${key}` }] };
+            }
+            case 'memory_get': {
+                const { data, error } = await supabase
+                    .from('user_context')
+                    .select('category, key, value')
+                    .eq('user_id', userId)
+                    .eq('app_id', appId);
+                if (error)
+                    throw error;
+                // Group by category
+                const grouped = {};
+                for (const item of data || []) {
+                    if (!grouped[item.category])
+                        grouped[item.category] = {};
+                    grouped[item.category][item.key] = item.value;
+                }
+                return { content: [{ type: 'text', text: JSON.stringify(grouped, null, 2) }] };
+            }
+            case 'memory_forget': {
+                const { key } = args;
+                const { error } = await supabase
+                    .from('user_context')
+                    .delete()
+                    .eq('user_id', userId)
+                    .eq('app_id', appId)
+                    .eq('key', key);
+                if (error)
+                    throw error;
+                return { content: [{ type: 'text', text: `✅ Deleted: ${key}` }] };
+            }
+            case 'project_save': {
+                const { name: projName, description, tech_stack, current_tasks } = args;
+                // Check if project exists
+                const { data: existing } = await supabase
+                    .from('projects')
+                    .select('id')
+                    .eq('user_id', userId)
+                    .eq('app_id', appId)
+                    .eq('name', projName)
+                    .single();
+                if (existing) {
+                    // Update
+                    const { error } = await supabase
+                        .from('projects')
+                        .update({
+                        description,
+                        tech_stack,
+                        current_tasks,
+                        last_active_at: new Date().toISOString()
+                    })
+                        .eq('id', existing.id);
+                    if (error)
+                        throw error;
+                    return { content: [{ type: 'text', text: `✅ Updated project: ${projName}` }] };
+                }
+                else {
+                    // Create
+                    const { error } = await supabase
+                        .from('projects')
+                        .insert({
+                        user_id: userId,
+                        app_id: appId,
+                        name: projName,
+                        description,
+                        tech_stack: tech_stack || [],
+                        current_tasks: current_tasks || [],
+                        status: 'active'
+                    });
+                    if (error)
+                        throw error;
+                    return { content: [{ type: 'text', text: `✅ Created project: ${projName}` }] };
+                }
+            }
+            case 'project_get': {
+                const { data, error } = await supabase
+                    .from('projects')
+                    .select('*')
+                    .eq('user_id', userId)
+                    .eq('app_id', appId)
+                    .eq('status', 'active')
+                    .order('last_active_at', { ascending: false })
+                    .limit(1)
+                    .single();
+                if (error && error.code !== 'PGRST116')
+                    throw error;
+                if (!data) {
+                    return { content: [{ type: 'text', text: 'No active project found.' }] };
+                }
+                return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
+            }
+            case 'history_save': {
+                const { summary, key_points, decisions } = args;
+                const { error } = await supabase
+                    .from('conversation_summaries')
+                    .insert({
+                    user_id: userId,
+                    app_id: appId,
+                    summary,
+                    key_points: key_points || [],
+                    decisions: decisions || []
+                });
+                if (error)
+                    throw error;
+                return { content: [{ type: 'text', text: '✅ Conversation summary saved' }] };
+            }
+            default:
+                return { content: [{ type: 'text', text: `Unknown tool: ${name}` }], isError: true };
+        }
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : 'Unknown error';
+        return { content: [{ type: 'text', text: `Error: ${message}` }], isError: true };
+    }
+});
+async function main() {
+    const transport = new stdio_js_1.StdioServerTransport();
+    await server.connect(transport);
+    console.error('Persista MCP server (direct) running');
+}
+main().catch((error) => {
+    console.error('Fatal error:', error);
+    process.exit(1);
+});

package/dist/index.d.ts

@@ -0,0 +1,42 @@
+#!/usr/bin/env node
+/**
+ * Persista MCP Server v3.0 - Complete AI Memory Infrastructure
+ *
+ * FEATURES:
+ * ═══════════════════════════════════════════════════════════════
+ *
+ * 🧠 MEMORY (v3)
+ * - Confidence decay over time
+ * - Semantic search
+ * - Auto-extraction from text
+ * - Code-attached memories
+ * - Memory history/versioning
+ * - Smart merge for conflicts
+ *
+ * 📝 CONTEXT (v3)
+ * - Relevance scoring
+ * - Smart context packing
+ * - Cross-session threading
+ * - Auto-compression
+ * - Milestone marking
+ *
+ * 🔄 SYNC (v3)
+ * - Intent broadcasting
+ * - Conflict detection
+ * - Auto-discovery
+ * - Cursor position sharing
+ *
+ * 📚 KNOWLEDGE (v3)
+ * - Version-aware queries
+ * - Deprecation scanning
+ * - User pattern learning
+ * - Migration guides
+ *
+ * 🚀 AUTO-HOOKS
+ * - Git tracking between sessions
+ * - Codebase analysis
+ * - Proactive context injection
+ * ═══════════════════════════════════════════════════════════════
+ */
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG"}