tachibot-mcp 2.0.2

package/dist/src/memory/index.js

@@ -0,0 +1,17 @@
+/**
+ * Memory System Module
+ * Exports all memory-related components
+ */
+// Core exports
+export * from './memory-config.js';
+export * from './memory-interface.js';
+export * from './memory-manager.js';
+// Provider exports
+export * from './providers/local-provider.js';
+export * from './providers/mem0-provider.js';
+// export * from './providers/devlog-provider.js';
+// export * from './providers/hybrid-provider.js';
+// Main API
+export { getMemoryManager, resetMemoryManager, HierarchicalMemoryManager } from './memory-manager.js';
+export { DEFAULT_MEMORY_CONFIG, loadMemoryConfigFromEnv, mergeMemoryConfig, validateMemoryConfig } from './memory-config.js';
+export { BaseMemoryProvider } from './memory-interface.js';

package/dist/src/memory/memory-config.js

@@ -0,0 +1,135 @@
+/**
+ * Memory Configuration System
+ * Flexible memory backend configuration with support for mem0, DevLog, local, and hybrid modes
+ */
+/**
+ * Default configuration
+ */
+export const DEFAULT_MEMORY_CONFIG = {
+    provider: 'local',
+    local: {
+        storageType: 'json',
+        path: './.focus-memory',
+        maxSizeMB: 100,
+        enableCompression: true
+    },
+    tiers: {
+        session: true,
+        working: true,
+        project: true,
+        team: false,
+        global: false
+    },
+    maxMemoryItems: 10000,
+    ttlMinutes: {
+        session: 30,
+        working: 120,
+        project: 43200, // 30 days
+        team: 129600, // 90 days
+        global: -1 // Never expires
+    },
+    enableAutoCleanup: true,
+    enableMetrics: false
+};
+/**
+ * Load configuration from environment variables
+ */
+export function loadMemoryConfigFromEnv() {
+    const config = {};
+    // Provider selection
+    const provider = process.env.MEMORY_PROVIDER;
+    if (provider) {
+        config.provider = provider;
+    }
+    // Mem0 configuration
+    if (process.env.MEM0_API_KEY) {
+        config.mem0 = {
+            apiKey: process.env.MEM0_API_KEY,
+            endpoint: process.env.MEM0_ENDPOINT,
+            userId: process.env.MEM0_USER_ID,
+            enableVectorSearch: process.env.MEM0_ENABLE_VECTOR !== 'false',
+            enableGraphMemory: process.env.MEM0_ENABLE_GRAPH !== 'false'
+        };
+    }
+    // DevLog configuration
+    if (process.env.DEVLOG_CONNECTION) {
+        config.devlog = {
+            connectionString: process.env.DEVLOG_CONNECTION,
+            workspace: process.env.DEVLOG_WORKSPACE,
+            projectId: process.env.DEVLOG_PROJECT,
+            enableSync: process.env.DEVLOG_SYNC !== 'false'
+        };
+    }
+    // Local storage configuration
+    if (process.env.LOCAL_STORAGE_PATH) {
+        config.local = {
+            storageType: process.env.LOCAL_STORAGE_TYPE || 'json',
+            path: process.env.LOCAL_STORAGE_PATH,
+            maxSizeMB: parseInt(process.env.LOCAL_STORAGE_MAX_MB || '100'),
+            enableCompression: process.env.LOCAL_STORAGE_COMPRESS !== 'false'
+        };
+    }
+    // Tier configuration
+    config.tiers = {
+        session: process.env.ENABLE_SESSION_MEMORY !== 'false',
+        working: process.env.ENABLE_WORKING_MEMORY !== 'false',
+        project: process.env.ENABLE_PROJECT_MEMORY !== 'false',
+        team: process.env.ENABLE_TEAM_MEMORY === 'true',
+        global: process.env.ENABLE_GLOBAL_MEMORY === 'true'
+    };
+    return config;
+}
+/**
+ * Merge configurations with defaults
+ */
+export function mergeMemoryConfig(userConfig, envConfig = loadMemoryConfigFromEnv()) {
+    // Priority: userConfig > envConfig > DEFAULT_MEMORY_CONFIG
+    return {
+        ...DEFAULT_MEMORY_CONFIG,
+        ...envConfig,
+        ...userConfig,
+        tiers: {
+            ...DEFAULT_MEMORY_CONFIG.tiers,
+            ...(envConfig.tiers || {}),
+            ...(userConfig.tiers || {})
+        },
+        ttlMinutes: {
+            ...DEFAULT_MEMORY_CONFIG.ttlMinutes,
+            ...(envConfig.ttlMinutes || {}),
+            ...(userConfig.ttlMinutes || {})
+        }
+    };
+}
+/**
+ * Validate memory configuration
+ */
+export function validateMemoryConfig(config) {
+    const errors = [];
+    // Validate provider-specific requirements
+    if (config.provider === 'mem0' && !config.mem0?.apiKey && !process.env.MEM0_API_KEY) {
+        errors.push('Mem0 provider requires API key (MEM0_API_KEY or config.mem0.apiKey)');
+    }
+    if (config.provider === 'devlog' && !config.devlog?.connectionString && !process.env.DEVLOG_CONNECTION) {
+        errors.push('DevLog provider requires connection string');
+    }
+    if (config.provider === 'local' && !config.local?.path) {
+        errors.push('Local provider requires storage path');
+    }
+    if (config.provider === 'hybrid') {
+        if (!config.hybrid?.primary || !config.hybrid?.fallback) {
+            errors.push('Hybrid provider requires both primary and fallback providers');
+        }
+        if (config.hybrid?.primary === config.hybrid?.fallback) {
+            errors.push('Hybrid primary and fallback must be different');
+        }
+    }
+    // Validate at least one tier is enabled
+    const tiersEnabled = Object.values(config.tiers).some(v => v);
+    if (!tiersEnabled && config.provider !== 'none') {
+        errors.push('At least one memory tier must be enabled');
+    }
+    return {
+        valid: errors.length === 0,
+        errors
+    };
+}

package/dist/src/memory/memory-interface.js

@@ -0,0 +1,174 @@
+/**
+ * Memory Provider Interface
+ * Common interface for all memory providers (mem0, DevLog, local, etc.)
+ */
+/**
+ * Abstract base class for memory providers with common functionality
+ */
+export class BaseMemoryProvider {
+    constructor() {
+        this.initialized = false;
+        this.metrics = {
+            totalItems: 0,
+            itemsByTier: {
+                session: 0,
+                working: 0,
+                project: 0,
+                team: 0,
+                global: 0
+            },
+            totalTokens: 0,
+            avgRetrievalTime: 0,
+            hitRate: 0,
+            storageUsedMB: 0
+        };
+    }
+    async initialize() {
+        if (this.initialized)
+            return;
+        await this.doInitialize();
+        this.initialized = true;
+    }
+    async storeBatch(items) {
+        const ids = [];
+        for (const item of items) {
+            const id = await this.store(item);
+            ids.push(id);
+        }
+        return ids;
+    }
+    async retrieveContext(query) {
+        // Default implementation - can be overridden
+        const items = await this.retrieve(query);
+        // Apply priority weights if specified
+        if (query.priorityWeights) {
+            items.sort((a, b) => {
+                const scoreA = this.calculatePriorityScore(a, query.priorityWeights);
+                const scoreB = this.calculatePriorityScore(b, query.priorityWeights);
+                return scoreB - scoreA;
+            });
+        }
+        // Limit by context window if specified
+        let selectedItems = items;
+        if (query.contextWindow) {
+            selectedItems = this.limitByTokens(items, query.contextWindow);
+        }
+        // Calculate source distribution
+        const sources = {
+            session: 0,
+            working: 0,
+            project: 0,
+            team: 0,
+            global: 0
+        };
+        selectedItems.forEach(item => {
+            sources[item.tier]++;
+        });
+        return {
+            items: selectedItems,
+            synthesis: this.synthesizeItems(selectedItems),
+            relevanceScore: this.calculateRelevanceScore(selectedItems, query),
+            tokenCount: this.estimateTokenCount(selectedItems),
+            sources
+        };
+    }
+    async deleteMany(query) {
+        const items = await this.retrieve(query);
+        let deleted = 0;
+        for (const item of items) {
+            if (await this.delete(item.id)) {
+                deleted++;
+            }
+        }
+        return deleted;
+    }
+    async cleanup() {
+        // Default implementation - remove expired items
+        const now = new Date();
+        let cleaned = 0;
+        // This would need to be implemented based on storage backend
+        // For now, return 0
+        return cleaned;
+    }
+    async getMetrics() {
+        return { ...this.metrics };
+    }
+    async isAvailable() {
+        return this.initialized;
+    }
+    async close() {
+        this.initialized = false;
+    }
+    /**
+     * Helper methods
+     */
+    calculatePriorityScore(item, weights) {
+        const now = Date.now();
+        const age = now - item.timestamp.getTime();
+        const recencyScore = Math.exp(-age / (1000 * 60 * 60 * 24)); // Decay over days
+        const frequencyScore = Math.min(1, (item.accessCount || 0) / 10);
+        // Relevance would need to be calculated based on query
+        const relevanceScore = 0.5; // Default middle value
+        return (weights.recency * recencyScore +
+            weights.relevance * relevanceScore +
+            weights.frequency * frequencyScore);
+    }
+    limitByTokens(items, maxTokens) {
+        const selected = [];
+        let totalTokens = 0;
+        for (const item of items) {
+            const itemTokens = this.estimateTokens(item.content);
+            if (totalTokens + itemTokens <= maxTokens) {
+                selected.push(item);
+                totalTokens += itemTokens;
+            }
+            else {
+                break;
+            }
+        }
+        return selected;
+    }
+    synthesizeItems(items) {
+        if (items.length === 0)
+            return '';
+        // Group by tier
+        const byTier = {
+            session: [],
+            working: [],
+            project: [],
+            team: [],
+            global: []
+        };
+        items.forEach(item => {
+            byTier[item.tier].push(item);
+        });
+        // Create synthesis
+        const parts = [];
+        if (byTier.session.length > 0) {
+            parts.push(`Recent context: ${byTier.session.map(i => i.content).join('; ')}`);
+        }
+        if (byTier.project.length > 0) {
+            parts.push(`Project context: ${byTier.project.map(i => i.content).join('; ')}`);
+        }
+        return parts.join('\n');
+    }
+    calculateRelevanceScore(items, query) {
+        if (items.length === 0)
+            return 0;
+        // Simple implementation - can be enhanced
+        return Math.min(1, items.length / 10);
+    }
+    estimateTokenCount(items) {
+        return items.reduce((sum, item) => sum + this.estimateTokens(item.content), 0);
+    }
+    estimateTokens(text) {
+        // Rough estimate: 1 token ≈ 4 characters
+        return Math.ceil(text.length / 4);
+    }
+    /**
+     * Generate unique ID
+     */
+    generateId() {
+        return `${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+    }
+}

package/dist/src/memory/memory-manager.js

@@ -0,0 +1,383 @@
+/**
+ * Hierarchical Memory Manager
+ * Orchestrates multiple memory providers and manages tier-based memory hierarchy
+ */
+import { mergeMemoryConfig, validateMemoryConfig } from './memory-config.js';
+import { LocalProvider } from './providers/local-provider.js';
+import { Mem0Provider } from './providers/mem0-provider.js';
+// import { DevLogProvider } from './providers/devlog-provider.js';
+// import { HybridProvider } from './providers/hybrid-provider.js';
+/**
+ * Main memory manager that coordinates all providers
+ */
+export class HierarchicalMemoryManager {
+    constructor(userConfig) {
+        this.provider = null;
+        // Tier-based cleanup intervals
+        this.cleanupIntervals = new Map();
+        this.config = mergeMemoryConfig(userConfig || {});
+        this.sessionId = this.generateSessionId();
+        // Validate configuration
+        const validation = validateMemoryConfig(this.config);
+        if (!validation.valid) {
+            console.error('Invalid memory configuration:', validation.errors);
+            // Fall back to local provider
+            this.config.provider = 'local';
+        }
+    }
+    /**
+     * Initialize the memory manager and selected provider
+     */
+    async initialize() {
+        console.error(`🧠 Initializing memory manager with ${this.config.provider} provider...`);
+        try {
+            // Create the appropriate provider
+            this.provider = await this.createProvider();
+            if (!this.provider) {
+                console.warn('Failed to create primary provider, falling back to local storage');
+                this.config.provider = 'local';
+                this.provider = await this.createLocalProvider();
+            }
+            // Set up automatic cleanup for each tier
+            if (this.config.enableAutoCleanup) {
+                this.setupAutoCleanup();
+            }
+            console.error(`✅ Memory manager initialized with ${this.provider.name} provider`);
+        }
+        catch (error) {
+            console.error('Failed to initialize memory manager:', error);
+            throw error;
+        }
+    }
+    /**
+     * Store a memory item with automatic tier assignment
+     */
+    async store(content, tier, metadata) {
+        if (!this.provider) {
+            throw new Error('Memory manager not initialized');
+        }
+        // Auto-assign tier based on context if not provided
+        if (!tier) {
+            tier = this.inferTier(content, metadata);
+        }
+        // Check if tier is enabled
+        if (!this.config.tiers[tier]) {
+            console.warn(`Tier ${tier} is disabled, upgrading to next available tier`);
+            const nextTier = this.getNextAvailableTier(tier);
+            if (!nextTier) {
+                throw new Error('No memory tiers are enabled');
+            }
+            tier = nextTier;
+        }
+        const item = {
+            id: this.generateId(),
+            content,
+            tier,
+            userId: this.userId,
+            projectId: this.projectId,
+            teamId: this.teamId,
+            timestamp: new Date(),
+            metadata: {
+                ...metadata,
+                sessionId: this.sessionId
+            },
+            ttl: this.config.ttlMinutes?.[tier]
+        };
+        return await this.provider.store(item);
+    }
+    /**
+     * Retrieve memories with hierarchical context
+     */
+    async retrieve(query) {
+        if (!this.provider) {
+            throw new Error('Memory manager not initialized');
+        }
+        // Build query with defaults
+        const fullQuery = {
+            userId: query?.userId || this.userId,
+            projectId: query?.projectId || this.projectId,
+            teamId: query?.teamId || this.teamId,
+            tiers: query?.tiers || this.getEnabledTiers(),
+            ...query
+        };
+        return await this.provider.retrieve(fullQuery);
+    }
+    /**
+     * Get contextual memories with synthesis
+     */
+    async getContext(text, maxTokens, options) {
+        if (!this.provider) {
+            throw new Error('Memory manager not initialized');
+        }
+        const query = {
+            text,
+            userId: this.userId,
+            projectId: this.projectId,
+            teamId: this.teamId,
+            tiers: this.getEnabledTiers(),
+            contextWindow: maxTokens || 2000,
+            priorityWeights: {
+                recency: 0.4,
+                relevance: 0.5,
+                frequency: 0.1,
+                ...options?.priorityWeights
+            },
+            ...options
+        };
+        return await this.provider.retrieveContext(query);
+    }
+    /**
+     * Promote memory to higher tier
+     */
+    async promote(itemId, newTier) {
+        if (!this.provider) {
+            throw new Error('Memory manager not initialized');
+        }
+        // Check if new tier is enabled
+        if (!this.config.tiers[newTier]) {
+            console.warn(`Cannot promote to disabled tier ${newTier}`);
+            return false;
+        }
+        return await this.provider.update(itemId, {
+            tier: newTier,
+            ttl: this.config.ttlMinutes?.[newTier]
+        });
+    }
+    /**
+     * Clean up expired memories
+     */
+    async cleanup() {
+        if (!this.provider) {
+            throw new Error('Memory manager not initialized');
+        }
+        return await this.provider.cleanup();
+    }
+    /**
+     * Get memory metrics
+     */
+    async getMetrics() {
+        if (!this.provider) {
+            throw new Error('Memory manager not initialized');
+        }
+        return await this.provider.getMetrics();
+    }
+    /**
+     * Semantic search across memories
+     */
+    async search(text, limit) {
+        if (!this.provider) {
+            throw new Error('Memory manager not initialized');
+        }
+        // Use semantic search if available
+        if (this.provider.semanticSearch) {
+            return await this.provider.semanticSearch(text, limit);
+        }
+        // Fall back to text-based search
+        return await this.retrieve({ text, limit });
+    }
+    /**
+     * Export all memories
+     */
+    async export() {
+        if (!this.provider) {
+            throw new Error('Memory manager not initialized');
+        }
+        return await this.provider.export();
+    }
+    /**
+     * Import memories
+     */
+    async import(items) {
+        if (!this.provider) {
+            throw new Error('Memory manager not initialized');
+        }
+        return await this.provider.import(items);
+    }
+    /**
+     * Set context (project, user, team)
+     */
+    setContext(context) {
+        if (context.projectId)
+            this.projectId = context.projectId;
+        if (context.userId)
+            this.userId = context.userId;
+        if (context.teamId)
+            this.teamId = context.teamId;
+    }
+    /**
+     * Start a new session
+     */
+    newSession() {
+        this.sessionId = this.generateSessionId();
+        return this.sessionId;
+    }
+    /**
+     * Close and cleanup
+     */
+    async close() {
+        // Clear cleanup intervals
+        this.cleanupIntervals.forEach(interval => clearInterval(interval));
+        this.cleanupIntervals.clear();
+        // Close provider
+        if (this.provider) {
+            await this.provider.close();
+            this.provider = null;
+        }
+    }
+    /**
+     * Private helper methods
+     */
+    async createProvider() {
+        switch (this.config.provider) {
+            case 'mem0':
+                if (!this.config.mem0) {
+                    console.error('Mem0 configuration missing');
+                    return null;
+                }
+                try {
+                    const provider = new Mem0Provider(this.config.mem0);
+                    await provider.initialize();
+                    return provider;
+                }
+                catch (error) {
+                    console.error('Failed to create Mem0 provider:', error);
+                    return null;
+                }
+            case 'devlog':
+                // TODO: Implement DevLog provider
+                console.warn('DevLog provider not yet implemented');
+                return null;
+            case 'local':
+                return await this.createLocalProvider();
+            case 'hybrid':
+                // TODO: Implement Hybrid provider
+                console.warn('Hybrid provider not yet implemented');
+                return null;
+            case 'none':
+                return null;
+            default:
+                console.warn(`Unknown provider: ${this.config.provider}`);
+                return null;
+        }
+    }
+    async createLocalProvider() {
+        const provider = new LocalProvider(this.config.local || {
+            storageType: 'json',
+            path: './.focus-memory',
+            maxSizeMB: 100
+        });
+        await provider.initialize();
+        return provider;
+    }
+    inferTier(content, metadata) {
+        // Infer based on content and metadata
+        if (metadata?.tier)
+            return metadata.tier;
+        // Default heuristics
+        const contentLength = content.length;
+        const hasCode = /```[\s\S]*?```/.test(content);
+        const hasImportantKeywords = /critical|important|remember|always|never/i.test(content);
+        if (hasImportantKeywords && this.config.tiers.project) {
+            return 'project';
+        }
+        if (hasCode && this.config.tiers.working) {
+            return 'working';
+        }
+        if (contentLength > 500 && this.config.tiers.working) {
+            return 'working';
+        }
+        return 'session';
+    }
+    getNextAvailableTier(tier) {
+        const tierOrder = ['session', 'working', 'project', 'team', 'global'];
+        const currentIndex = tierOrder.indexOf(tier);
+        for (let i = currentIndex + 1; i < tierOrder.length; i++) {
+            if (this.config.tiers[tierOrder[i]]) {
+                return tierOrder[i];
+            }
+        }
+        // Try lower tiers
+        for (let i = currentIndex - 1; i >= 0; i--) {
+            if (this.config.tiers[tierOrder[i]]) {
+                return tierOrder[i];
+            }
+        }
+        return null;
+    }
+    getEnabledTiers() {
+        const tiers = [];
+        const allTiers = ['session', 'working', 'project', 'team', 'global'];
+        allTiers.forEach(tier => {
+            if (this.config.tiers[tier]) {
+                tiers.push(tier);
+            }
+        });
+        return tiers;
+    }
+    setupAutoCleanup() {
+        const tiers = ['session', 'working', 'project', 'team', 'global'];
+        tiers.forEach(tier => {
+            if (this.config.tiers[tier] && this.config.ttlMinutes?.[tier]) {
+                const ttl = this.config.ttlMinutes[tier];
+                if (ttl > 0) {
+                    // Run cleanup at 1/4 of TTL interval
+                    const interval = Math.max(60000, (ttl * 60 * 1000) / 4); // Min 1 minute
+                    const intervalId = setInterval(async () => {
+                        try {
+                            await this.cleanupTier(tier);
+                        }
+                        catch (error) {
+                            console.error(`Failed to cleanup ${tier} tier:`, error);
+                        }
+                    }, interval);
+                    this.cleanupIntervals.set(tier, intervalId);
+                }
+            }
+        });
+    }
+    async cleanupTier(tier) {
+        if (!this.provider)
+            return;
+        const ttl = this.config.ttlMinutes?.[tier];
+        if (!ttl || ttl <= 0)
+            return;
+        const cutoffDate = new Date(Date.now() - (ttl * 60 * 1000));
+        const query = {
+            tiers: [tier],
+            endDate: cutoffDate
+        };
+        const deleted = await this.provider.deleteMany(query);
+        if (deleted > 0) {
+            console.error(`🗑️ Cleaned up ${deleted} expired ${tier} memories`);
+        }
+    }
+    generateId() {
+        return `${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+    }
+    generateSessionId() {
+        return `session-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+    }
+}
+/**
+ * Singleton instance
+ */
+let memoryManager = null;
+/**
+ * Get or create memory manager instance
+ */
+export async function getMemoryManager(config) {
+    if (!memoryManager) {
+        memoryManager = new HierarchicalMemoryManager(config);
+        await memoryManager.initialize();
+    }
+    return memoryManager;
+}
+/**
+ * Reset memory manager (useful for testing)
+ */
+export async function resetMemoryManager() {
+    if (memoryManager) {
+        await memoryManager.close();
+        memoryManager = null;
+    }
+}