couchloop-eq-mcp 1.0.3 → 1.0.5

package/dist/developer/guards/file-guardian.js

@@ -0,0 +1,309 @@
+import path from 'path';
+import { logger } from '../../utils/logger.js';
+/**
+ * File Guardian - Detects and prevents destructive file operations
+ * Protects against accidental deletion, overwriting, and data loss
+ */
+// Patterns that ALWAYS require confirmation before modification/deletion
+const PROTECTED_PATTERNS = [
+    '.env*',
+    '*.key',
+    '*.pem',
+    '*.secret',
+    '*.credentials',
+    'database.sqlite',
+    'production.json',
+    'secrets.json',
+    'config.json',
+    'package.json',
+    'package-lock.json',
+    'yarn.lock',
+];
+// Paths that should NEVER be deleted (code freeze)
+const FORBIDDEN_PATHS = [
+    '.git',
+    '.gitignore',
+    'node_modules',
+    'dist',
+    'build',
+    '.next',
+    '.env.production',
+    '.env.staging',
+    'Dockerfile',
+    '.dockerignore',
+];
+// System/critical files
+const CRITICAL_SYSTEM_FILES = [
+    '.env',
+    '.env.local',
+    '.env.production',
+    '.env.staging',
+    'package.json',
+    'tsconfig.json',
+    'eslint.config.js',
+    'vitest.config.ts',
+    'drizzle.config.ts',
+];
+// Dangerous operations that require explicit confirmation
+const DANGEROUS_OPERATIONS = ['rm -rf', 'rm -f', 'delete', 'unlink', 'truncate'];
+export class FileGuardian {
+    codeFreezeMode = false;
+    operationLog = [];
+    constructor() {
+        this.codeFreezeMode = process.env.CODE_FREEZE_MODE === 'true';
+    }
+    /**
+     * Enable code freeze mode - all file operations require approval
+     */
+    enableCodeFreezeMode() {
+        this.codeFreezeMode = true;
+        logger.info('Code freeze mode ENABLED - all file operations require approval');
+    }
+    /**
+     * Disable code freeze mode
+     */
+    disableCodeFreezeMode() {
+        this.codeFreezeMode = false;
+        logger.info('Code freeze mode disabled');
+    }
+    /**
+     * Check if a file path matches a protected pattern
+     */
+    matchesProtectedPattern(filePath) {
+        const fileName = path.basename(filePath);
+        return PROTECTED_PATTERNS.some(pattern => {
+            const globPattern = pattern.replace(/\*/g, '.*');
+            const regex = new RegExp(`^${globPattern}$`);
+            return regex.test(fileName);
+        });
+    }
+    /**
+     * Check if a path is forbidden (should never be deleted)
+     */
+    isForbiddenPath(filePath) {
+        const normalized = path.normalize(filePath);
+        return FORBIDDEN_PATHS.some(forbidden => {
+            return normalized.includes(forbidden) || path.basename(normalized) === forbidden;
+        });
+    }
+    /**
+     * Check if this is a critical system file
+     */
+    isCriticalSystemFile(filePath) {
+        const fileName = path.basename(filePath);
+        return CRITICAL_SYSTEM_FILES.includes(fileName);
+    }
+    /**
+     * Check if operation is dangerous
+     */
+    isDangerousOperation(operation) {
+        return DANGEROUS_OPERATIONS.some(op => operation.toLowerCase().includes(op));
+    }
+    /**
+     * Validate file deletion operation
+     */
+    validateDelete(filePath, _force = false) {
+        const violations = [];
+        // Check if path is forbidden
+        if (this.isForbiddenPath(filePath)) {
+            violations.push({
+                type: 'forbidden_path',
+                path: filePath,
+                message: `Path '${filePath}' is protected and cannot be deleted. This directory/file is critical to system operation.`,
+                severity: 'critical',
+            });
+        }
+        // Check for critical system files
+        if (this.isCriticalSystemFile(filePath)) {
+            violations.push({
+                type: 'system_file',
+                path: filePath,
+                message: `System file '${filePath}' requires special approval before deletion.`,
+                severity: 'high',
+            });
+        }
+        // Check protected patterns
+        if (this.matchesProtectedPattern(filePath)) {
+            violations.push({
+                type: 'protected_pattern',
+                path: filePath,
+                message: `File '${filePath}' matches protected pattern. Credentials/configs must not be deleted.`,
+                severity: 'critical',
+            });
+        }
+        // Code freeze mode check
+        if (this.codeFreezeMode) {
+            violations.push({
+                type: 'dangerous_operation',
+                path: filePath,
+                message: `Code freeze mode is ENABLED. All delete operations require explicit approval. Cannot proceed.`,
+                severity: 'critical',
+            });
+        }
+        return violations;
+    }
+    /**
+     * Validate file overwrite operation
+     */
+    validateOverwrite(filePath, _force = false) {
+        const violations = [];
+        // Check for critical system files
+        if (this.isCriticalSystemFile(filePath)) {
+            violations.push({
+                type: 'system_file',
+                path: filePath,
+                message: `System file '${filePath}' cannot be overwritten without backup and approval.`,
+                severity: 'high',
+            });
+        }
+        // Check protected patterns
+        if (this.matchesProtectedPattern(filePath)) {
+            violations.push({
+                type: 'protected_pattern',
+                path: filePath,
+                message: `File '${filePath}' is protected. Overwriting credentials/configs is dangerous.`,
+                severity: 'critical',
+            });
+        }
+        // Code freeze mode check
+        if (this.codeFreezeMode) {
+            violations.push({
+                type: 'dangerous_operation',
+                path: filePath,
+                message: `Code freeze mode is ENABLED. All file modifications require explicit approval.`,
+                severity: 'critical',
+            });
+        }
+        return violations;
+    }
+    /**
+     * Validate file move operation
+     */
+    validateMove(sourcePath, targetPath, _force = false) {
+        const violations = [];
+        // Check if source is forbidden
+        if (this.isForbiddenPath(sourcePath)) {
+            violations.push({
+                type: 'forbidden_path',
+                path: sourcePath,
+                message: `Cannot move protected path '${sourcePath}'`,
+                severity: 'critical',
+            });
+        }
+        // Check if source is critical
+        if (this.isCriticalSystemFile(sourcePath)) {
+            violations.push({
+                type: 'system_file',
+                path: sourcePath,
+                message: `Cannot move critical system file '${sourcePath}' without backup.`,
+                severity: 'high',
+            });
+        }
+        // Warn if target path suggests unsafe operation
+        if (this.isForbiddenPath(targetPath)) {
+            violations.push({
+                type: 'dangerous_operation',
+                path: targetPath,
+                message: `Moving to protected location '${targetPath}' may cause issues.`,
+                severity: 'high',
+            });
+        }
+        // Code freeze mode check
+        if (this.codeFreezeMode) {
+            violations.push({
+                type: 'dangerous_operation',
+                path: sourcePath,
+                message: `Code freeze mode is ENABLED. All file operations require explicit approval.`,
+                severity: 'critical',
+            });
+        }
+        return violations;
+    }
+    /**
+     * Perform comprehensive file operation validation
+     */
+    validateOperation(operation, filePath, targetPath, force = false) {
+        let violations = [];
+        switch (operation) {
+            case 'delete':
+                violations = this.validateDelete(filePath, force);
+                break;
+            case 'overwrite':
+                violations = this.validateOverwrite(filePath, force);
+                break;
+            case 'move':
+                violations = this.validateMove(filePath, targetPath || '', force);
+                break;
+        }
+        // Determine severity from violations
+        let maxSeverity = 'none';
+        for (const violation of violations) {
+            if (violation.severity === 'critical') {
+                maxSeverity = 'critical';
+            }
+            else if (violation.severity === 'high' && maxSeverity !== 'critical') {
+                maxSeverity = 'high';
+            }
+            else if (violation.severity === 'medium' && maxSeverity === 'none') {
+                maxSeverity = 'medium';
+            }
+        }
+        return {
+            allowed: violations.length === 0,
+            violations,
+            requiresApproval: violations.length > 0,
+            severity: maxSeverity,
+        };
+    }
+    /**
+     * Log a file operation
+     */
+    logOperation(operation) {
+        this.operationLog.push({
+            ...operation,
+            timestamp: new Date(),
+        });
+        logger.info(`File operation logged: ${operation.operation} on ${operation.path} - Status: ${operation.status}`);
+        // Keep only last 100 operations
+        if (this.operationLog.length > 100) {
+            this.operationLog = this.operationLog.slice(-100);
+        }
+    }
+    /**
+     * Get operation history
+     */
+    getOperationHistory(limit = 50) {
+        return this.operationLog.slice(-limit);
+    }
+    /**
+     * Get protected paths configuration
+     */
+    getProtectionConfig() {
+        return {
+            protectedPatterns: PROTECTED_PATTERNS,
+            forbiddenPaths: FORBIDDEN_PATHS,
+            criticalSystemFiles: CRITICAL_SYSTEM_FILES,
+            codeFreezeMode: this.codeFreezeMode,
+        };
+    }
+    /**
+     * Generate protection report
+     */
+    getProtectionReport() {
+        const recentViolations = [];
+        // Extract violations from recent operations
+        for (const _op of this.operationLog.slice(-20)) {
+            // This would need to store violations in FileOperation
+            // For now, return empty
+        }
+        return {
+            codeFreezeEnabled: this.codeFreezeMode,
+            totalOperationsLogged: this.operationLog.length,
+            recentViolations,
+            protectedItemsCount: PROTECTED_PATTERNS.length + FORBIDDEN_PATHS.length,
+        };
+    }
+}
+// Export singleton instance
+export const fileGuardian = new FileGuardian();
+//# sourceMappingURL=file-guardian.js.map

package/dist/developer/guards/file-guardian.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"file-guardian.js","sourceRoot":"","sources":["../../../src/developer/guards/file-guardian.ts"],"names":[],"mappings":"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"}

package/dist/developer/managers/context-manager.d.ts

@@ -0,0 +1,61 @@
+import { ContextEntry, ContextCategoryType, PreserveContextResponse } from '../../types/context.js';
+interface ContextStore {
+    version: string;
+    entries: ContextEntry[];
+    metadata: {
+        created_at: string;
+        last_updated: string;
+    };
+}
+export declare class ContextManager {
+    private store;
+    private isInitialized;
+    constructor();
+    /**
+     * Initialize the context store from disk
+     */
+    initialize(): Promise<void>;
+    /**
+     * Store a context entry
+     */
+    storeEntry(category: ContextCategoryType, content: string): Promise<PreserveContextResponse>;
+    /**
+     * Retrieve context entries by category or search term
+     */
+    retrieve(category?: ContextCategoryType, searchTerm?: string): Promise<PreserveContextResponse>;
+    /**
+     * Check context window status and provide warnings if needed
+     */
+    check(includeMetadata?: boolean): Promise<PreserveContextResponse>;
+    /**
+     * Get metadata about the context store
+     */
+    private getMetadata;
+    /**
+     * Clear old or unused context entries (cleanup)
+     */
+    cleanup(daysOld?: number): Promise<PreserveContextResponse>;
+    /**
+     * Export all context for backup
+     */
+    export(): Promise<ContextStore>;
+    /**
+     * Import context from backup
+     */
+    import(store: ContextStore): Promise<void>;
+    /**
+     * Create default context store
+     */
+    private createDefaultStore;
+    /**
+     * Save store to disk
+     */
+    private save;
+    /**
+     * Ensure manager is initialized
+     */
+    private ensureInitialized;
+}
+export declare function getContextManager(): Promise<ContextManager>;
+export {};
+//# sourceMappingURL=context-manager.d.ts.map

package/dist/developer/managers/context-manager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"context-manager.d.ts","sourceRoot":"","sources":["../../../src/developer/managers/context-manager.ts"],"names":[],"mappings":"AAIA,OAAO,EACL,YAAY,EACZ,mBAAmB,EAEnB,uBAAuB,EACxB,MAAM,wBAAwB,CAAC;AAMhC,UAAU,YAAY;IACpB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,YAAY,EAAE,CAAC;IACxB,QAAQ,EAAE;QACR,UAAU,EAAE,MAAM,CAAC;QACnB,YAAY,EAAE,MAAM,CAAC;KACtB,CAAC;CACH;AAED,qBAAa,cAAc;IACzB,OAAO,CAAC,KAAK,CAAe;IAC5B,OAAO,CAAC,aAAa,CAAS;;IAa9B;;OAEG;IACG,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IA0BjC;;OAEG;IACG,UAAU,CACd,QAAQ,EAAE,mBAAmB,EAC7B,OAAO,EAAE,MAAM,GACd,OAAO,CAAC,uBAAuB,CAAC;IA+BnC;;OAEG;IACG,QAAQ,CACZ,QAAQ,CAAC,EAAE,mBAAmB,EAC9B,UAAU,CAAC,EAAE,MAAM,GAClB,OAAO,CAAC,uBAAuB,CAAC;IAmDnC;;OAEG;IACG,KAAK,CAAC,eAAe,GAAE,OAAe,GAAG,OAAO,CAAC,uBAAuB,CAAC;IAmC/E;;OAEG;IACH,OAAO,CAAC,WAAW;IA6BnB;;OAEG;IACG,OAAO,CAAC,OAAO,GAAE,MAAW,GAAG,OAAO,CAAC,uBAAuB,CAAC;IA8BrE;;OAEG;IACG,MAAM,IAAI,OAAO,CAAC,YAAY,CAAC;IAKrC;;OAEG;IACG,MAAM,CAAC,KAAK,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC;IAYhD;;OAEG;IACH,OAAO,CAAC,kBAAkB;IAsC1B;;OAEG;IACH,OAAO,CAAC,IAAI;IAaZ;;OAEG;IACH,OAAO,CAAC,iBAAiB;CAO1B;AAKD,wBAAsB,iBAAiB,IAAI,OAAO,CAAC,cAAc,CAAC,CAMjE"}

package/dist/developer/managers/context-manager.js

@@ -0,0 +1,302 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { nanoid } from 'nanoid';
+import { logger } from '../../utils/logger.js';
+const CONTEXT_STORE_PATH = path.join(process.cwd(), 'src', 'db', 'context-store.json');
+const MAX_CONTEXT_WINDOW_TOKENS = 200000; // Approximate token limit
+const AVG_CHARS_PER_TOKEN = 4; // Average characters per token
+export class ContextManager {
+    store;
+    isInitialized = false;
+    constructor() {
+        this.store = {
+            version: '1.0.0',
+            entries: [],
+            metadata: {
+                created_at: new Date().toISOString(),
+                last_updated: new Date().toISOString(),
+            },
+        };
+    }
+    /**
+     * Initialize the context store from disk
+     */
+    async initialize() {
+        try {
+            // Create parent directory if it doesn't exist
+            const dir = path.dirname(CONTEXT_STORE_PATH);
+            if (!fs.existsSync(dir)) {
+                fs.mkdirSync(dir, { recursive: true });
+            }
+            // Load existing store or create new one
+            if (fs.existsSync(CONTEXT_STORE_PATH)) {
+                const data = fs.readFileSync(CONTEXT_STORE_PATH, 'utf-8');
+                this.store = JSON.parse(data);
+                logger.info(`Loaded context store with ${this.store.entries.length} entries`);
+            }
+            else {
+                this.createDefaultStore();
+                this.save();
+                logger.info('Created new context store');
+            }
+            this.isInitialized = true;
+        }
+        catch (error) {
+            logger.error('Failed to initialize context manager:', error);
+            throw new Error(`Context manager initialization failed: ${error}`);
+        }
+    }
+    /**
+     * Store a context entry
+     */
+    async storeEntry(category, content) {
+        this.ensureInitialized();
+        try {
+            const entry = {
+                id: nanoid(),
+                category,
+                content,
+                timestamp: new Date(),
+                usage_count: 0,
+                last_retrieved: null,
+            };
+            this.store.entries.push(entry);
+            this.store.metadata.last_updated = new Date().toISOString();
+            this.save();
+            logger.info(`Stored context entry: ${entry.id} in category: ${category}`);
+            return {
+                success: true,
+                action: 'store',
+                message: `Successfully stored context in "${category}" category`,
+                data: [entry],
+            };
+        }
+        catch (error) {
+            logger.error('Error storing context:', error);
+            throw new Error(`Failed to store context: ${error}`);
+        }
+    }
+    /**
+     * Retrieve context entries by category or search term
+     */
+    async retrieve(category, searchTerm) {
+        this.ensureInitialized();
+        try {
+            let results = this.store.entries;
+            // Filter by category if provided
+            if (category) {
+                results = results.filter((e) => e.category === category);
+            }
+            // Filter by search term if provided
+            if (searchTerm) {
+                const term = searchTerm.toLowerCase();
+                results = results.filter((e) => e.content.toLowerCase().includes(term));
+            }
+            // Update usage count and last retrieved timestamp
+            results.forEach((entry) => {
+                entry.usage_count += 1;
+                entry.last_retrieved = new Date();
+            });
+            this.store.metadata.last_updated = new Date().toISOString();
+            this.save();
+            if (results.length === 0) {
+                return {
+                    success: true,
+                    action: 'retrieve',
+                    message: `No context found${category ? ` in category "${category}"` : ''}${searchTerm ? ` matching "${searchTerm}"` : ''}`,
+                    data: null,
+                };
+            }
+            logger.info(`Retrieved ${results.length} context entries`);
+            return {
+                success: true,
+                action: 'retrieve',
+                message: `Retrieved ${results.length} context entries`,
+                data: results,
+            };
+        }
+        catch (error) {
+            logger.error('Error retrieving context:', error);
+            throw new Error(`Failed to retrieve context: ${error}`);
+        }
+    }
+    /**
+     * Check context window status and provide warnings if needed
+     */
+    async check(includeMetadata = false) {
+        this.ensureInitialized();
+        try {
+            const metadata = this.getMetadata();
+            let warning;
+            if (metadata.context_window_usage_percent > 80) {
+                warning = `Context window is ${metadata.context_window_usage_percent.toFixed(1)}% full. Consider archiving or cleaning up old context entries.`;
+            }
+            else if (metadata.context_window_usage_percent > 60) {
+                warning = `Context window is ${metadata.context_window_usage_percent.toFixed(1)}% full. You may want to monitor usage.`;
+            }
+            const response = {
+                success: true,
+                action: 'check',
+                message: `Context store contains ${metadata.total_entries} entries`,
+                warning,
+            };
+            if (includeMetadata) {
+                response.data = metadata;
+            }
+            return response;
+        }
+        catch (error) {
+            logger.error('Error checking context:', error);
+            throw new Error(`Failed to check context: ${error}`);
+        }
+    }
+    /**
+     * Get metadata about the context store
+     */
+    getMetadata() {
+        const entriesByCategory = {
+            architecture: 0,
+            requirements: 0,
+            constraints: 0,
+            decisions: 0,
+            'technical-patterns': 0,
+            'project-metadata': 0,
+        };
+        let totalBytes = 0;
+        this.store.entries.forEach((entry) => {
+            entriesByCategory[entry.category]++;
+            totalBytes += entry.content.length;
+        });
+        const estimatedTokens = totalBytes / AVG_CHARS_PER_TOKEN;
+        const usagePercent = (estimatedTokens / MAX_CONTEXT_WINDOW_TOKENS) * 100;
+        return {
+            total_entries: this.store.entries.length,
+            entries_by_category: entriesByCategory,
+            total_stored_bytes: totalBytes,
+            last_updated: new Date(this.store.metadata.last_updated),
+            context_window_usage_percent: Math.min(usagePercent, 100),
+        };
+    }
+    /**
+     * Clear old or unused context entries (cleanup)
+     */
+    async cleanup(daysOld = 30) {
+        this.ensureInitialized();
+        try {
+            const cutoffDate = new Date();
+            cutoffDate.setDate(cutoffDate.getDate() - daysOld);
+            const beforeCount = this.store.entries.length;
+            this.store.entries = this.store.entries.filter((entry) => {
+                const entryDate = new Date(entry.timestamp);
+                return entryDate > cutoffDate;
+            });
+            const removedCount = beforeCount - this.store.entries.length;
+            this.store.metadata.last_updated = new Date().toISOString();
+            this.save();
+            logger.info(`Cleaned up ${removedCount} context entries older than ${daysOld} days`);
+            return {
+                success: true,
+                action: 'retrieve',
+                message: `Removed ${removedCount} entries older than ${daysOld} days`,
+            };
+        }
+        catch (error) {
+            logger.error('Error cleaning context:', error);
+            throw new Error(`Failed to cleanup context: ${error}`);
+        }
+    }
+    /**
+     * Export all context for backup
+     */
+    async export() {
+        this.ensureInitialized();
+        return JSON.parse(JSON.stringify(this.store));
+    }
+    /**
+     * Import context from backup
+     */
+    async import(store) {
+        try {
+            this.store = store;
+            this.store.metadata.last_updated = new Date().toISOString();
+            this.save();
+            logger.info('Imported context store');
+        }
+        catch (error) {
+            logger.error('Error importing context:', error);
+            throw new Error(`Failed to import context: ${error}`);
+        }
+    }
+    /**
+     * Create default context store
+     */
+    createDefaultStore() {
+        this.store = {
+            version: '1.0.0',
+            entries: [
+                {
+                    id: nanoid(),
+                    category: 'project-metadata',
+                    content: 'CouchLoop MCP Server - Model Context Protocol server for stateful conversation management',
+                    timestamp: new Date(),
+                    usage_count: 0,
+                    last_retrieved: null,
+                },
+                {
+                    id: nanoid(),
+                    category: 'architecture',
+                    content: 'CouchLoop uses PostgreSQL via Supabase with Drizzle ORM. MCP protocol via stdio for communication. Session/journey/checkpoint management.',
+                    timestamp: new Date(),
+                    usage_count: 0,
+                    last_retrieved: null,
+                },
+                {
+                    id: nanoid(),
+                    category: 'requirements',
+                    content: 'Must support multi-turn conversations, session persistence across interruptions, guided journeys, crisis detection via shrink-chat integration',
+                    timestamp: new Date(),
+                    usage_count: 0,
+                    last_retrieved: null,
+                },
+            ],
+            metadata: {
+                created_at: new Date().toISOString(),
+                last_updated: new Date().toISOString(),
+            },
+        };
+    }
+    /**
+     * Save store to disk
+     */
+    save() {
+        try {
+            const dir = path.dirname(CONTEXT_STORE_PATH);
+            if (!fs.existsSync(dir)) {
+                fs.mkdirSync(dir, { recursive: true });
+            }
+            fs.writeFileSync(CONTEXT_STORE_PATH, JSON.stringify(this.store, null, 2), 'utf-8');
+        }
+        catch (error) {
+            logger.error('Failed to save context store:', error);
+            throw new Error(`Failed to persist context: ${error}`);
+        }
+    }
+    /**
+     * Ensure manager is initialized
+     */
+    ensureInitialized() {
+        if (!this.isInitialized) {
+            throw new Error('ContextManager not initialized. Call initialize() before using other methods.');
+        }
+    }
+}
+// Singleton instance
+let instance = null;
+export async function getContextManager() {
+    if (!instance) {
+        instance = new ContextManager();
+        await instance.initialize();
+    }
+    return instance;
+}
+//# sourceMappingURL=context-manager.js.map