polydev-ai 1.2.3 → 1.2.4

package/README.md

@@ -1,6 +1,6 @@
 # Polydev AI Website
 
-Advanced Model Context Protocol platform with comprehensive multi-LLM integration, subscription-based CLI access, OAuth bridges, and advanced tooling for AI development.
+Advanced Model Context Protocol platform with comprehensive multi-LLM integrations, subscription-based CLI access, OAuth bridges, and advanced tooling for AI development.
 
 ## Features
 

package/lib/universalMemoryExtractor.js

@@ -0,0 +1,607 @@
+"use strict";
+/**
+ * Universal Memory Extraction System
+ * Extracts memory from ALL CLI tools with zero-knowledge encryption
+ * Preserves existing functionality while adding comprehensive memory support
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.universalMemoryExtractor = exports.UniversalMemoryExtractor = void 0;
+const promises_1 = __importDefault(require("fs/promises"));
+const path_1 = __importDefault(require("path"));
+const os_1 = __importDefault(require("os"));
+const server_1 = require("@/app/utils/supabase/server");
+const zeroKnowledgeEncryption_1 = require("./zeroKnowledgeEncryption");
+class UniversalMemoryExtractor {
+    constructor() {
+        // Memory location patterns for all supported CLI tools
+        this.MEMORY_PATTERNS = {
+            claude_code: {
+                global: [
+                    '~/.claude/CLAUDE.md',
+                    '~/.claude/global_memory.md',
+                    '~/.claude/config.json'
+                ],
+                project: [
+                    'CLAUDE.md',
+                    '.claude/CLAUDE.md',
+                    '.claude/project_memory.md'
+                ],
+                conversations: [
+                    '~/.claude/projects/*/conversations/*.jsonl',
+                    '~/.claude/conversations/*.jsonl'
+                ],
+                config: ['~/.claude/config.json']
+            },
+            cline: {
+                global: [
+                    '~/.cline/global_memory.md',
+                    '~/.cline/settings.json',
+                    '~/.cline/config.json'
+                ],
+                project: [
+                    '.cline/project_memory.md',
+                    '.cline/cline_project.json',
+                    '.cline/memory.md'
+                ],
+                conversations: [
+                    '.cline/conversations/*.json',
+                    '.cline/chat_history.json'
+                ],
+                config: ['.cline/cline_config.json', '.cline/settings.json']
+            },
+            codex_cli: {
+                global: [
+                    '~/.codex/memory.json',
+                    '~/.codex/config.yaml',
+                    '~/.codex/global_context.md'
+                ],
+                project: [
+                    '.codex/project_context.json',
+                    '.codex/memory.md',
+                    '.codex/context.json'
+                ],
+                conversations: [
+                    '~/.codex/conversations/*.json',
+                    '.codex/history.json'
+                ],
+                config: ['~/.codex/config.json', '~/.codex/config.yaml']
+            },
+            cursor: {
+                global: [
+                    '~/.cursor/memory.json',
+                    '~/.cursor/settings.json',
+                    '~/.cursor/global_context.md'
+                ],
+                project: [
+                    '.cursor/project.json',
+                    '.cursor/workspace_context.json',
+                    '.cursor/memory.md'
+                ],
+                conversations: [
+                    '.cursor/chat_history.json',
+                    '.cursor/conversations/*.json'
+                ],
+                config: ['.cursor/settings.json']
+            },
+            continue: {
+                global: [
+                    '~/.continue/config.json',
+                    '~/.continue/memory.json',
+                    '~/.continue/global_context.md'
+                ],
+                project: [
+                    '.continue/config.json',
+                    '.continue/memory.md',
+                    '.continue/project_context.json'
+                ],
+                conversations: [
+                    '.continue/sessions/*.json',
+                    '.continue/chat_history.json'
+                ],
+                config: ['.continue/config.json']
+            },
+            aider: {
+                global: [
+                    '~/.aider.conf.yml',
+                    '~/.aider/memory.json',
+                    '~/.aider/global_context.md'
+                ],
+                project: [
+                    '.aider.conf.yml',
+                    '.aider/project_memory.md',
+                    '.aider/context.md'
+                ],
+                conversations: [
+                    '.aider/chat_history.json',
+                    '.aider/sessions/*.json'
+                ],
+                config: ['.aider.conf.yml']
+            },
+            generic: {
+                global: [
+                    '~/.ai/global_memory.md',
+                    '~/.ai/config.json'
+                ],
+                project: [
+                    'ai_memory.md',
+                    'project_context.md',
+                    '.ai/memory.json',
+                    '.ai/context.md'
+                ],
+                conversations: [
+                    'ai_conversations.json',
+                    '.ai/history.json',
+                    'chat_history.json'
+                ],
+                config: ['~/.ai/config.json']
+            }
+        };
+        this.homeDir = os_1.default.homedir();
+        this.encryption = new zeroKnowledgeEncryption_1.ZeroKnowledgeEncryption();
+    }
+    /**
+     * Initialize the memory extractor
+     */
+    async initialize() {
+        await this.encryption.initialize();
+    }
+    /**
+     * Detect all available memory sources for specified CLI tools
+     */
+    async detectMemorySources(projectPath = process.cwd(), cliTools = ['all']) {
+        const sources = [];
+        const toolsToCheck = cliTools.includes('all')
+            ? Object.keys(this.MEMORY_PATTERNS)
+            : cliTools;
+        for (const tool of toolsToCheck) {
+            const patterns = this.MEMORY_PATTERNS[tool];
+            if (!patterns)
+                continue;
+            // Check global memory sources
+            if (patterns.global) {
+                for (const pattern of patterns.global) {
+                    const resolved = this.resolvePath(pattern);
+                    const exists = await this.fileExists(resolved);
+                    sources.push({
+                        cli_tool: tool,
+                        memory_type: 'global',
+                        file_path: resolved,
+                        exists,
+                        ...(exists && await this.getFileStats(resolved))
+                    });
+                }
+            }
+            // Check project memory sources
+            if (patterns.project) {
+                for (const pattern of patterns.project) {
+                    const resolved = path_1.default.resolve(projectPath, pattern);
+                    const exists = await this.fileExists(resolved);
+                    sources.push({
+                        cli_tool: tool,
+                        memory_type: 'project',
+                        file_path: resolved,
+                        exists,
+                        ...(exists && await this.getFileStats(resolved))
+                    });
+                }
+            }
+            // Check conversation sources (simplified glob pattern matching)
+            if (patterns.conversations) {
+                for (const pattern of patterns.conversations) {
+                    const conversationSources = await this.findConversationFiles(pattern, projectPath);
+                    sources.push(...conversationSources.map(filePath => ({
+                        cli_tool: tool,
+                        memory_type: 'conversation',
+                        file_path: filePath,
+                        exists: true
+                    })));
+                }
+            }
+        }
+        return sources.filter(source => source.exists);
+    }
+    /**
+     * Extract memory from detected sources
+     */
+    async extractMemory(sources, options = {}) {
+        const { encryptContent = true, maxFileSizeKB = 500, relevanceThreshold = 0.3 } = options;
+        const extractedMemories = [];
+        for (const source of sources) {
+            if (!source.exists)
+                continue;
+            try {
+                // Skip large files
+                if (source.size_bytes && source.size_bytes > maxFileSizeKB * 1024) {
+                    console.warn(`[Memory Extractor] Skipping large file: ${source.file_path} (${source.size_bytes} bytes)`);
+                    continue;
+                }
+                const content = await promises_1.default.readFile(source.file_path, 'utf-8');
+                const relevanceScore = this.calculateRelevanceScore(content, source);
+                // Skip low-relevance content
+                if (relevanceScore < relevanceThreshold) {
+                    continue;
+                }
+                const extractedMemory = {
+                    source,
+                    content,
+                    relevance_score: relevanceScore,
+                    extraction_method: this.getExtractionMethod(source),
+                    project_identifier: this.extractProjectIdentifier(source.file_path)
+                };
+                extractedMemories.push(extractedMemory);
+            }
+            catch (error) {
+                console.warn(`[Memory Extractor] Failed to read ${source.file_path}:`, error);
+                continue;
+            }
+        }
+        return extractedMemories.sort((a, b) => b.relevance_score - a.relevance_score);
+    }
+    /**
+     * Extract recent conversations from CLI tools
+     */
+    async extractRecentConversations(sources, options = {}) {
+        const { limit = 10, timeRangeHours = 24, queryContext = '' } = options;
+        const conversations = [];
+        const cutoffTime = new Date(Date.now() - timeRangeHours * 60 * 60 * 1000);
+        const conversationSources = sources.filter(s => s.memory_type === 'conversation');
+        for (const source of conversationSources) {
+            try {
+                const content = await promises_1.default.readFile(source.file_path, 'utf-8');
+                const extracted = this.parseConversations(content, source.cli_tool, cutoffTime);
+                conversations.push(...extracted);
+            }
+            catch (error) {
+                console.warn(`[Memory Extractor] Failed to parse conversations from ${source.file_path}:`, error);
+            }
+        }
+        // Sort by relevance if query context provided, otherwise by timestamp
+        if (queryContext) {
+            conversations.forEach(conv => {
+                conv.relevance_score = this.calculateConversationRelevance(conv, queryContext);
+            });
+            conversations.sort((a, b) => (b.relevance_score || 0) - (a.relevance_score || 0));
+        }
+        else {
+            conversations.sort((a, b) => b.timestamp.getTime() - a.timestamp.getTime());
+        }
+        return conversations.slice(0, limit);
+    }
+    /**
+     * Store extracted memory in database with encryption
+     */
+    async storeMemory(userId, extractedMemories, useEncryption = true) {
+        const supabase = await (0, server_1.createClient)();
+        for (const memory of extractedMemories) {
+            try {
+                let storedContent = memory.content;
+                let encryptedContent = null;
+                let contentHash;
+                if (useEncryption) {
+                    const encrypted = await this.encryption.encrypt(memory.content);
+                    encryptedContent = JSON.stringify(encrypted);
+                    contentHash = await this.encryption.createContentHash(memory.content);
+                }
+                else {
+                    contentHash = await this.encryption.createContentHash(memory.content);
+                }
+                const sourcePathHash = await this.encryption.createContentHash(memory.source.file_path);
+                // Insert into user_cli_memory_sources
+                await supabase
+                    .from('user_cli_memory_sources')
+                    .upsert({
+                    user_id: userId,
+                    cli_tool: memory.source.cli_tool,
+                    memory_type: memory.source.memory_type,
+                    source_path_hash: sourcePathHash,
+                    encrypted_content: encryptedContent,
+                    content_hash: contentHash,
+                    file_count: 1,
+                    last_modified: memory.source.last_modified?.toISOString(),
+                    extraction_method: memory.extraction_method,
+                    relevance_score: memory.relevance_score,
+                    project_identifier: memory.project_identifier,
+                    encryption_version: useEncryption ? 1 : 0
+                }, {
+                    onConflict: 'user_id,cli_tool,memory_type,source_path_hash'
+                });
+                // Log the extraction for audit
+                await this.logMemoryAccess(userId, {
+                    action_type: 'extract',
+                    cli_tool: memory.source.cli_tool,
+                    memory_type: memory.source.memory_type,
+                    sources_processed: 1,
+                    bytes_processed: memory.content.length,
+                    privacy_mode: useEncryption
+                });
+            }
+            catch (error) {
+                console.error(`[Memory Extractor] Failed to store memory for ${memory.source.file_path}:`, error);
+            }
+        }
+    }
+    /**
+     * Store conversations with encryption
+     */
+    async storeConversations(userId, conversations, useEncryption = true) {
+        const supabase = await (0, server_1.createClient)();
+        for (const conv of conversations) {
+            try {
+                let encryptedUserMessage = null;
+                let encryptedAssistantResponse = null;
+                let conversationHash;
+                const conversationText = `${conv.user_message}\n\n${conv.assistant_response}`;
+                if (useEncryption) {
+                    const encryptedUser = await this.encryption.encrypt(conv.user_message);
+                    const encryptedAssistant = await this.encryption.encrypt(conv.assistant_response);
+                    encryptedUserMessage = JSON.stringify(encryptedUser);
+                    encryptedAssistantResponse = JSON.stringify(encryptedAssistant);
+                    conversationHash = await this.encryption.createContentHash(conversationText);
+                }
+                else {
+                    conversationHash = await this.encryption.createContentHash(conversationText);
+                }
+                // Insert into mcp_conversation_memory (extending existing table)
+                await supabase
+                    .from('mcp_conversation_memory')
+                    .upsert({
+                    user_id: userId,
+                    user_message: useEncryption ? '' : conv.user_message,
+                    assistant_response: useEncryption ? '' : conv.assistant_response,
+                    encrypted_user_message: encryptedUserMessage,
+                    encrypted_assistant_response: encryptedAssistantResponse,
+                    model_used: conv.model_used || 'unknown',
+                    tokens_used: conv.tokens_used || 0,
+                    conversation_hash: conversationHash,
+                    encryption_version: useEncryption ? 1 : 0,
+                    privacy_mode: useEncryption,
+                    created_at: conv.timestamp.toISOString()
+                }, {
+                    onConflict: 'conversation_hash'
+                });
+            }
+            catch (error) {
+                console.error('[Memory Extractor] Failed to store conversation:', error);
+            }
+        }
+    }
+    /**
+     * Get comprehensive memory context for injection
+     */
+    async getContextForInjection(userId, queryContext = '', options = {}) {
+        const supabase = await (0, server_1.createClient)();
+        const { maxMemoryKB = 50, maxConversations = 6 } = options;
+        let memory = '';
+        let conversations = '';
+        let totalSize = 0;
+        const sourcesUsed = [];
+        try {
+            // Get relevant memory sources
+            const { data: memorySources } = await supabase
+                .from('user_cli_memory_sources')
+                .select('*')
+                .eq('user_id', userId)
+                .gte('relevance_score', 0.5)
+                .order('relevance_score', { ascending: false })
+                .limit(20);
+            if (memorySources) {
+                for (const source of memorySources) {
+                    if (totalSize > maxMemoryKB * 1024)
+                        break;
+                    let content = '';
+                    if (source.encrypted_content) {
+                        try {
+                            const encryptedData = JSON.parse(source.encrypted_content);
+                            content = await this.encryption.decrypt(encryptedData);
+                        }
+                        catch (error) {
+                            console.warn('[Memory Context] Failed to decrypt memory source:', error);
+                            continue;
+                        }
+                    }
+                    if (content) {
+                        const contextEntry = `[${source.cli_tool}:${source.memory_type}]\n${content}\n\n`;
+                        if (totalSize + contextEntry.length <= maxMemoryKB * 1024) {
+                            memory += contextEntry;
+                            totalSize += contextEntry.length;
+                            sourcesUsed.push(`${source.cli_tool}:${source.memory_type}`);
+                        }
+                    }
+                }
+            }
+            // Get relevant conversations
+            const { data: recentConversations } = await supabase
+                .from('mcp_conversation_memory')
+                .select('*')
+                .eq('user_id', userId)
+                .order('created_at', { ascending: false })
+                .limit(maxConversations);
+            if (recentConversations) {
+                for (const conv of recentConversations.slice(0, maxConversations)) {
+                    let userMsg = conv.user_message;
+                    let assistantResp = conv.assistant_response;
+                    if (conv.encrypted_user_message && conv.encrypted_assistant_response) {
+                        try {
+                            const encryptedUser = JSON.parse(conv.encrypted_user_message);
+                            const encryptedAssistant = JSON.parse(conv.encrypted_assistant_response);
+                            userMsg = await this.encryption.decrypt(encryptedUser);
+                            assistantResp = await this.encryption.decrypt(encryptedAssistant);
+                        }
+                        catch (error) {
+                            console.warn('[Memory Context] Failed to decrypt conversation:', error);
+                            continue;
+                        }
+                    }
+                    const convEntry = `[Conversation ${conv.created_at}]\nUser: ${userMsg}\nAssistant: ${assistantResp}\n\n`;
+                    conversations += convEntry;
+                }
+            }
+        }
+        catch (error) {
+            console.error('[Memory Context] Failed to get context:', error);
+        }
+        return {
+            memory: memory.trim(),
+            conversations: conversations.trim(),
+            totalSizeKB: Math.round(totalSize / 1024),
+            sourcesUsed
+        };
+    }
+    // Private helper methods
+    resolvePath(pathPattern) {
+        return pathPattern.replace('~', this.homeDir);
+    }
+    async fileExists(filePath) {
+        try {
+            await promises_1.default.access(filePath);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async getFileStats(filePath) {
+        const stats = await promises_1.default.stat(filePath);
+        return {
+            size_bytes: stats.size,
+            last_modified: stats.mtime
+        };
+    }
+    async findConversationFiles(pattern, projectPath) {
+        const files = [];
+        try {
+            const resolved = pattern.includes('~') ? this.resolvePath(pattern) : path_1.default.resolve(projectPath, pattern);
+            const dir = path_1.default.dirname(resolved.replace('*', ''));
+            if (await this.fileExists(dir)) {
+                const entries = await promises_1.default.readdir(dir);
+                for (const entry of entries) {
+                    const fullPath = path_1.default.join(dir, entry);
+                    const stats = await promises_1.default.stat(fullPath);
+                    if (stats.isFile() && (entry.endsWith('.json') || entry.endsWith('.jsonl'))) {
+                        files.push(fullPath);
+                    }
+                }
+            }
+        }
+        catch (error) {
+            // Silently handle directory access errors
+        }
+        return files;
+    }
+    calculateRelevanceScore(content, source) {
+        let score = 0.5; // Base score
+        // Boost for project-level memory
+        if (source.memory_type === 'project')
+            score += 0.2;
+        // Boost for recent conversations
+        if (source.memory_type === 'conversation')
+            score += 0.1;
+        // Boost for certain CLI tools
+        if (['claude_code', 'cursor', 'cline'].includes(source.cli_tool))
+            score += 0.1;
+        // Content quality indicators
+        if (content.includes('TODO') || content.includes('FIXME'))
+            score += 0.1;
+        if (content.includes('pattern') || content.includes('decision'))
+            score += 0.1;
+        if (content.length > 1000 && content.length < 10000)
+            score += 0.1;
+        return Math.min(score, 1.0);
+    }
+    getExtractionMethod(source) {
+        const ext = path_1.default.extname(source.file_path).toLowerCase();
+        switch (ext) {
+            case '.md': return 'markdown_parse';
+            case '.json': return 'json_parse';
+            case '.jsonl': return 'jsonl_parse';
+            case '.yml':
+            case '.yaml': return 'yaml_parse';
+            default: return 'text_parse';
+        }
+    }
+    extractProjectIdentifier(filePath) {
+        const parts = filePath.split(path_1.default.sep);
+        const projectIndex = parts.findIndex(part => !part.startsWith('.') && part !== 'home' && part !== 'Users');
+        return projectIndex >= 0 ? parts.slice(projectIndex, projectIndex + 2).join('/') : 'unknown';
+    }
+    parseConversations(content, cliTool, cutoffTime) {
+        const conversations = [];
+        try {
+            if (cliTool === 'claude_code' && content.includes('"type":"message"')) {
+                // Parse Claude Code JSONL format
+                const lines = content.split('\n').filter(line => line.trim());
+                for (const line of lines) {
+                    try {
+                        const entry = JSON.parse(line);
+                        if (entry.type === 'message' && entry.timestamp) {
+                            const timestamp = new Date(entry.timestamp);
+                            if (timestamp > cutoffTime) {
+                                conversations.push({
+                                    timestamp,
+                                    user_message: entry.content || '',
+                                    assistant_response: entry.response || '',
+                                    model_used: entry.model,
+                                    tokens_used: entry.tokens
+                                });
+                            }
+                        }
+                    }
+                    catch { }
+                }
+            }
+            else if (content.startsWith('[') || content.startsWith('{')) {
+                // Parse JSON format conversations
+                const data = JSON.parse(content);
+                const messages = Array.isArray(data) ? data : data.messages || [];
+                for (let i = 0; i < messages.length - 1; i += 2) {
+                    const userMsg = messages[i];
+                    const assistantMsg = messages[i + 1];
+                    if (userMsg && assistantMsg) {
+                        const timestamp = new Date(userMsg.timestamp || assistantMsg.timestamp || Date.now());
+                        if (timestamp > cutoffTime) {
+                            conversations.push({
+                                timestamp,
+                                user_message: userMsg.content || userMsg.text || '',
+                                assistant_response: assistantMsg.content || assistantMsg.text || '',
+                                model_used: assistantMsg.model,
+                                tokens_used: assistantMsg.tokens
+                            });
+                        }
+                    }
+                }
+            }
+        }
+        catch (error) {
+            console.warn(`[Memory Extractor] Failed to parse conversations for ${cliTool}:`, error);
+        }
+        return conversations;
+    }
+    calculateConversationRelevance(conversation, queryContext) {
+        if (!queryContext)
+            return 0.5;
+        const text = `${conversation.user_message} ${conversation.assistant_response}`.toLowerCase();
+        const queryWords = queryContext.toLowerCase().split(/\s+/);
+        const matches = queryWords.filter(word => text.includes(word)).length;
+        return Math.min(matches / queryWords.length, 1.0);
+    }
+    async logMemoryAccess(userId, logData) {
+        const supabase = await (0, server_1.createClient)();
+        try {
+            await supabase
+                .from('user_memory_audit_log')
+                .insert({
+                user_id: userId,
+                ...logData
+            });
+        }
+        catch (error) {
+            console.error('[Memory Extractor] Failed to log memory access:', error);
+        }
+    }
+}
+exports.UniversalMemoryExtractor = UniversalMemoryExtractor;
+// Export singleton instance
+exports.universalMemoryExtractor = new UniversalMemoryExtractor();

package/lib/zeroKnowledgeEncryption.js

@@ -0,0 +1,289 @@
+"use strict";
+/**
+ * Zero-Knowledge Client-Side Encryption System
+ * All encryption keys never leave the user's browser
+ * Enterprise-grade AES-256-GCM encryption with automatic key rotation
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.zkEncryption = exports.ZeroKnowledgeEncryption = void 0;
+class ZeroKnowledgeEncryption {
+    constructor() {
+        this.db = null;
+        this.activeKey = null;
+    }
+    /**
+     * Initialize the encryption system
+     */
+    async initialize() {
+        await this.initializeIndexedDB();
+        await this.loadOrCreateActiveKey();
+    }
+    /**
+     * Initialize IndexedDB for local key storage
+     */
+    async initializeIndexedDB() {
+        return new Promise((resolve, reject) => {
+            const request = indexedDB.open(ZeroKnowledgeEncryption.DB_NAME, ZeroKnowledgeEncryption.DB_VERSION);
+            request.onerror = () => reject(request.error);
+            request.onsuccess = () => {
+                this.db = request.result;
+                resolve();
+            };
+            request.onupgradeneeded = (event) => {
+                const db = event.target.result;
+                // Store for encryption keys (never synchronized)
+                if (!db.objectStoreNames.contains('keys')) {
+                    const keyStore = db.createObjectStore('keys', { keyPath: 'keyId' });
+                    keyStore.createIndex('created', 'created', { unique: false });
+                }
+                // Cache for encrypted data
+                if (!db.objectStoreNames.contains('cache')) {
+                    const cacheStore = db.createObjectStore('cache', { keyPath: 'id' });
+                    cacheStore.createIndex('expires', 'expires', { unique: false });
+                }
+            };
+        });
+    }
+    /**
+     * Generate new AES-256-GCM encryption key
+     */
+    async generateKey() {
+        const keyId = this.generateKeyId();
+        const key = await window.crypto.subtle.generateKey({
+            name: ZeroKnowledgeEncryption.ALGORITHM,
+            length: ZeroKnowledgeEncryption.KEY_LENGTH,
+        }, true, // extractable for storage
+        ['encrypt', 'decrypt']);
+        const now = new Date();
+        const rotationDue = new Date(now.getTime() + (ZeroKnowledgeEncryption.KEY_ROTATION_DAYS * 24 * 60 * 60 * 1000));
+        return {
+            keyId,
+            key,
+            created: now,
+            rotationDue
+        };
+    }
+    /**
+     * Load active key or create new one
+     */
+    async loadOrCreateActiveKey() {
+        if (!this.db)
+            throw new Error('Database not initialized');
+        const transaction = this.db.transaction(['keys'], 'readonly');
+        const store = transaction.objectStore('keys');
+        // Get the most recent key
+        const index = store.index('created');
+        const request = index.openCursor(null, 'prev');
+        return new Promise((resolve) => {
+            request.onsuccess = async (event) => {
+                const cursor = event.target.result;
+                if (cursor) {
+                    const keyData = cursor.value;
+                    // Check if key needs rotation
+                    if (new Date() > new Date(keyData.rotationDue)) {
+                        console.log('[ZK Encryption] Key rotation needed, generating new key');
+                        await this.createAndStoreKey();
+                    }
+                    else {
+                        // Import existing key
+                        const keyBuffer = new Uint8Array(keyData.keyBuffer);
+                        this.activeKey = {
+                            keyId: keyData.keyId,
+                            key: await window.crypto.subtle.importKey('raw', keyBuffer, { name: ZeroKnowledgeEncryption.ALGORITHM }, true, ['encrypt', 'decrypt']),
+                            created: new Date(keyData.created),
+                            rotationDue: new Date(keyData.rotationDue)
+                        };
+                    }
+                }
+                else {
+                    // No keys exist, create first one
+                    await this.createAndStoreKey();
+                }
+                resolve();
+            };
+        });
+    }
+    /**
+     * Create and store new key
+     */
+    async createAndStoreKey() {
+        this.activeKey = await this.generateKey();
+        await this.storeKey(this.activeKey);
+    }
+    /**
+     * Store key in IndexedDB
+     */
+    async storeKey(userKey) {
+        if (!this.db)
+            throw new Error('Database not initialized');
+        const keyBuffer = await window.crypto.subtle.exportKey('raw', userKey.key);
+        const transaction = this.db.transaction(['keys'], 'readwrite');
+        const store = transaction.objectStore('keys');
+        await store.put({
+            keyId: userKey.keyId,
+            keyBuffer: Array.from(new Uint8Array(keyBuffer)),
+            created: userKey.created.toISOString(),
+            rotationDue: userKey.rotationDue.toISOString()
+        });
+    }
+    /**
+     * Encrypt sensitive data
+     */
+    async encrypt(plaintext) {
+        if (!this.activeKey)
+            throw new Error('Encryption key not available');
+        const encoder = new TextEncoder();
+        const data = encoder.encode(plaintext);
+        const iv = window.crypto.getRandomValues(new Uint8Array(ZeroKnowledgeEncryption.IV_LENGTH));
+        const encrypted = await window.crypto.subtle.encrypt({
+            name: ZeroKnowledgeEncryption.ALGORITHM,
+            iv: iv,
+        }, this.activeKey.key, data);
+        const encryptedArray = new Uint8Array(encrypted);
+        const ciphertext = encryptedArray.slice(0, -ZeroKnowledgeEncryption.AUTH_TAG_LENGTH);
+        const authTag = encryptedArray.slice(-ZeroKnowledgeEncryption.AUTH_TAG_LENGTH);
+        return {
+            ciphertext: this.arrayBufferToBase64(ciphertext.buffer),
+            iv: this.arrayBufferToBase64(iv.buffer),
+            authTag: this.arrayBufferToBase64(authTag.buffer),
+            keyId: this.activeKey.keyId,
+            version: 1
+        };
+    }
+    /**
+     * Decrypt sensitive data
+     */
+    async decrypt(encryptedData) {
+        const key = await this.getKeyById(encryptedData.keyId);
+        if (!key)
+            throw new Error(`Encryption key ${encryptedData.keyId} not found`);
+        const ciphertext = this.base64ToArrayBuffer(encryptedData.ciphertext);
+        const iv = this.base64ToArrayBuffer(encryptedData.iv);
+        const authTag = this.base64ToArrayBuffer(encryptedData.authTag);
+        // Combine ciphertext and auth tag for Web Crypto API
+        const combined = new Uint8Array(ciphertext.byteLength + authTag.byteLength);
+        combined.set(new Uint8Array(ciphertext));
+        combined.set(new Uint8Array(authTag), ciphertext.byteLength);
+        const decrypted = await window.crypto.subtle.decrypt({
+            name: ZeroKnowledgeEncryption.ALGORITHM,
+            iv: new Uint8Array(iv),
+        }, key, combined);
+        const decoder = new TextDecoder();
+        return decoder.decode(decrypted);
+    }
+    /**
+     * Get encryption key by ID
+     */
+    async getKeyById(keyId) {
+        if (!this.db)
+            return null;
+        const transaction = this.db.transaction(['keys'], 'readonly');
+        const store = transaction.objectStore('keys');
+        const request = store.get(keyId);
+        return new Promise((resolve) => {
+            request.onsuccess = async () => {
+                if (request.result) {
+                    const keyBuffer = new Uint8Array(request.result.keyBuffer);
+                    const key = await window.crypto.subtle.importKey('raw', keyBuffer, { name: ZeroKnowledgeEncryption.ALGORITHM }, true, ['encrypt', 'decrypt']);
+                    resolve(key);
+                }
+                else {
+                    resolve(null);
+                }
+            };
+            request.onerror = () => resolve(null);
+        });
+    }
+    /**
+     * Create SHA-256 hash for content deduplication
+     */
+    async createContentHash(content) {
+        const encoder = new TextEncoder();
+        const data = encoder.encode(content);
+        const hashBuffer = await window.crypto.subtle.digest('SHA-256', data);
+        return this.arrayBufferToHex(hashBuffer);
+    }
+    /**
+     * Check if key rotation is needed
+     */
+    isRotationDue() {
+        return this.activeKey ? new Date() > this.activeKey.rotationDue : true;
+    }
+    /**
+     * Force key rotation
+     */
+    async rotateKeys() {
+        await this.createAndStoreKey();
+        console.log('[ZK Encryption] Key rotation completed');
+    }
+    /**
+     * Generate unique key ID
+     */
+    generateKeyId() {
+        const timestamp = Date.now().toString(36);
+        const random = Math.random().toString(36).substr(2, 9);
+        return `zk_${timestamp}_${random}`;
+    }
+    /**
+     * Utility: ArrayBuffer to Base64
+     */
+    arrayBufferToBase64(buffer) {
+        const bytes = new Uint8Array(buffer);
+        let binary = '';
+        for (let i = 0; i < bytes.byteLength; i++) {
+            binary += String.fromCharCode(bytes[i]);
+        }
+        return btoa(binary);
+    }
+    /**
+     * Utility: Base64 to ArrayBuffer
+     */
+    base64ToArrayBuffer(base64) {
+        const binary = atob(base64);
+        const bytes = new Uint8Array(binary.length);
+        for (let i = 0; i < binary.length; i++) {
+            bytes[i] = binary.charCodeAt(i);
+        }
+        return bytes.buffer;
+    }
+    /**
+     * Utility: ArrayBuffer to Hex
+     */
+    arrayBufferToHex(buffer) {
+        const bytes = new Uint8Array(buffer);
+        return Array.from(bytes, byte => byte.toString(16).padStart(2, '0')).join('');
+    }
+    /**
+     * Get encryption status for dashboard
+     */
+    getEncryptionStatus() {
+        return {
+            keyId: this.activeKey?.keyId || null,
+            created: this.activeKey?.created || null,
+            rotationDue: this.activeKey?.rotationDue || null,
+            rotationNeeded: this.isRotationDue()
+        };
+    }
+    /**
+     * Clear all keys (for user logout/reset)
+     */
+    async clearAllKeys() {
+        if (!this.db)
+            return;
+        const transaction = this.db.transaction(['keys', 'cache'], 'readwrite');
+        await transaction.objectStore('keys').clear();
+        await transaction.objectStore('cache').clear();
+        this.activeKey = null;
+        console.log('[ZK Encryption] All keys cleared');
+    }
+}
+exports.ZeroKnowledgeEncryption = ZeroKnowledgeEncryption;
+ZeroKnowledgeEncryption.ALGORITHM = 'AES-GCM';
+ZeroKnowledgeEncryption.KEY_LENGTH = 256;
+ZeroKnowledgeEncryption.IV_LENGTH = 12;
+ZeroKnowledgeEncryption.AUTH_TAG_LENGTH = 16;
+ZeroKnowledgeEncryption.KEY_ROTATION_DAYS = 30;
+ZeroKnowledgeEncryption.DB_NAME = 'PolydevZKMemory';
+ZeroKnowledgeEncryption.DB_VERSION = 1;
+// Export singleton instance
+exports.zkEncryption = new ZeroKnowledgeEncryption();

package/mcp/manifest.json

@@ -198,7 +198,7 @@
       ]
     },
     {
-      "name": "polydev.force_cli_detection",
+      "name": "force_cli_detection",
       "description": "Force detection and status update for CLI tools (Claude Code, Codex CLI, Gemini CLI). Updates local cache and reports status to MCP server via Supabase.",
       "inputSchema": {
         "type": "object",
@@ -290,7 +290,7 @@
       ]
     },
     {
-      "name": "polydev.get_cli_status",
+      "name": "get_cli_status",
       "description": "Get current CLI status with caching support. Returns cached results if available and fresh, otherwise performs new detection.",
       "inputSchema": {
         "type": "object",
@@ -347,7 +347,7 @@
       }
     },
     {
-      "name": "polydev.send_cli_prompt",
+      "name": "send_cli_prompt",
       "description": "Send a prompt to a CLI provider and get response. Supports both stdin and argument modes for maximum compatibility.",
       "inputSchema": {
         "type": "object",
@@ -443,7 +443,7 @@
       ]
     },
     {
-      "name": "polydev.detect_memory_sources",
+      "name": "detect_memory_sources",
       "description": "Detect all available memory sources across CLI tools (Claude Code, Cline, Codex, Cursor, Continue, Aider). Returns file paths for global memory, project memory, and recent conversations.",
       "inputSchema": {
         "type": "object",
@@ -503,7 +503,7 @@
       }
     },
     {
-      "name": "polydev.extract_memory", 
+      "name": "extract_memory", 
       "description": "Extract and optionally encrypt memory content from detected CLI tool sources. Provides TF-IDF relevance scoring and content analysis.",
       "inputSchema": {
         "type": "object",
@@ -550,7 +550,7 @@
       }
     },
     {
-      "name": "polydev.get_recent_conversations",
+      "name": "get_recent_conversations",
       "description": "Get recent conversations from CLI tools with TF-IDF relevance scoring against query context. Supports encrypted storage and retrieval.",
       "inputSchema": {
         "type": "object",
@@ -590,7 +590,7 @@
       }
     },
     {
-      "name": "polydev.get_memory_context",
+      "name": "get_memory_context",
       "description": "Get formatted memory and conversation context for injection into prompts. Automatically handles decryption and relevance scoring.",
       "inputSchema": {
         "type": "object",
@@ -631,7 +631,7 @@
       }
     },
     {
-      "name": "polydev.manage_memory_preferences", 
+      "name": "manage_memory_preferences", 
       "description": "Configure memory extraction and privacy preferences. Control which CLI tools and memory types are enabled, encryption settings, and context injection behavior.",
       "inputSchema": {
         "type": "object",

package/mcp/server.js

@@ -1,9 +1,32 @@
 #!/usr/bin/env node
 
+// Register ts-node for TypeScript support
+try {
+  require('ts-node/register');
+} catch (e) {
+  // ts-node not available, proceed without it
+}
+
 const fs = require('fs');
 const path = require('path');
 const CLIManager = require('../lib/cliManager').default;
-const UniversalMemoryExtractor = require('../src/lib/universalMemoryExtractor').UniversalMemoryExtractor;
+
+let UniversalMemoryExtractor;
+try {
+  UniversalMemoryExtractor = require('../src/lib/universalMemoryExtractor').UniversalMemoryExtractor;
+} catch (e) {
+  // Fallback if TypeScript module is not available
+  console.warn('UniversalMemoryExtractor not available, memory features will be disabled');
+  UniversalMemoryExtractor = class {
+    async detectMemorySources() { return []; }
+    async extractMemory() { return {}; }
+    async getRecentConversations() { return []; }
+    async getRelevantContext() { return ''; }
+    async getPreferences() { return {}; }
+    async updatePreferences() { return {}; }
+    async resetPreferences() { return {}; }
+  };
+}
 
 class MCPServer {
   constructor() {
@@ -126,35 +149,35 @@ class MCPServer {
           result = await this.callPerspectivesAPI(args);
           break;
         
-        case 'polydev.force_cli_detection':
+        case 'force_cli_detection':
           result = await this.forceCliDetection(args);
           break;
         
-        case 'polydev.get_cli_status':
+        case 'get_cli_status':
           result = await this.getCliStatus(args);
           break;
         
-        case 'polydev.send_cli_prompt':
+        case 'send_cli_prompt':
           result = await this.sendCliPrompt(args);
           break;
         
-        case 'polydev.detect_memory_sources':
+        case 'detect_memory_sources':
           result = await this.detectMemorySources(args);
           break;
         
-        case 'polydev.extract_memory':
+        case 'extract_memory':
           result = await this.extractMemory(args);
           break;
         
-        case 'polydev.get_recent_conversations':
+        case 'get_recent_conversations':
           result = await this.getRecentConversations(args);
           break;
         
-        case 'polydev.get_memory_context':
+        case 'get_memory_context':
           result = await this.getMemoryContext(args);
           break;
         
-        case 'polydev.manage_memory_preferences':
+        case 'manage_memory_preferences':
           result = await this.manageMemoryPreferences(args);
           break;
         
@@ -298,20 +321,20 @@ class MCPServer {
       case 'get_perspectives':
         return this.formatPerspectivesResponse(result);
       
-      case 'polydev.force_cli_detection':
+      case 'force_cli_detection':
         return this.formatCliDetectionResponse(result);
-      
-      case 'polydev.get_cli_status':
+
+      case 'get_cli_status':
         return this.formatCliStatusResponse(result);
-      
-      case 'polydev.send_cli_prompt':
+
+      case 'send_cli_prompt':
         return this.formatCliPromptResponse(result);
-      
-      case 'polydev.detect_memory_sources':
-      case 'polydev.extract_memory':
-      case 'polydev.get_recent_conversations':
-      case 'polydev.get_memory_context':
-      case 'polydev.manage_memory_preferences':
+
+      case 'detect_memory_sources':
+      case 'extract_memory':
+      case 'get_recent_conversations':
+      case 'get_memory_context':
+      case 'manage_memory_preferences':
         return this.formatMemoryResponse(result);
       
       default:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "polydev-ai",
-  "version": "1.2.3",
+  "version": "1.2.4",
   "description": "Agentic workflow assistant with CLI integration - get diverse perspectives from multiple LLMs when stuck or need enhanced reasoning",
   "keywords": [
     "mcp",
@@ -69,6 +69,7 @@
     "sonner": "^2.0.7",
     "stripe": "^18.5.0",
     "tailwind-merge": "^3.3.1",
+    "ts-node": "^10.9.2",
     "which": "^5.0.0"
   },
   "devDependencies": {