mark-improving-agent 2.2.0

package/dist/core/cognition/learning-from-failure.js

@@ -0,0 +1,184 @@
+/**
+ * Learning from Failure - PSO-Inspired Error Recovery
+ *
+ * Paper: "AgentPSO: Evolving Reasoning" - Particle Swarm Optimization for agents
+ * Key insight: Errors are learning opportunities, not just failures
+ *
+ * Key mechanisms:
+ * - Error pattern encoding
+ * - Counterfactual reasoning: "What if I had done X instead?"
+ * - Failure trajectory tracking
+ * - Adaptive correction based on past errors
+ */
+import { randomUUID } from 'crypto';
+const MAX_FAILURES = 1000;
+const PATTERN_THRESHOLD = 3; // Times pattern must repeat before becoming a "known" pattern
+export function createLearningFromFailure() {
+    const failures = new Map();
+    const patterns = new Map();
+    function generateCounterfactual(action, result) {
+        // Generate "What if?" scenarios
+        const scenarios = [
+            `What if I had paused to analyze before ${action}?`,
+            `What if I had verified the ${result} before proceeding?`,
+            `What if I had asked for clarification instead of assuming?`,
+            `What if I had checked the lesson bank first?`,
+            `What if I had used the self-verification engine?`,
+        ];
+        return scenarios[Math.floor(Math.random() * scenarios.length)];
+    }
+    function extractErrorType(error, context) {
+        const errorLower = error.toLowerCase();
+        const contextLower = context.toLowerCase();
+        if (errorLower.includes('not found') || errorLower.includes('no such')) {
+            return 'resource_not_found';
+        }
+        if (errorLower.includes('permission') || errorLower.includes('access')) {
+            return 'permission_denied';
+        }
+        if (errorLower.includes('timeout') || errorLower.includes('slow')) {
+            return 'timeout';
+        }
+        if (errorLower.includes('invalid') || errorLower.includes('wrong')) {
+            return 'invalid_input';
+        }
+        if (contextLower.includes('search')) {
+            return 'search_failure';
+        }
+        if (contextLower.includes('verify')) {
+            return 'verification_failure';
+        }
+        return 'unknown_error';
+    }
+    function recordFailure(error, context, action, result) {
+        const id = `fail-${Date.now()}-${randomUUID().slice(0, 8)}`;
+        const errorType = extractErrorType(error, context);
+        const counterfactual = generateCounterfactual(action, result);
+        const record = {
+            id,
+            errorType,
+            context,
+            action,
+            result,
+            counterfactual,
+            lessons: [],
+            timestamp: Date.now(),
+            recurrenceCount: 1,
+            resolved: false,
+        };
+        // Enforce max failures limit
+        if (failures.size >= MAX_FAILURES) {
+            const oldest = Array.from(failures.values())
+                .sort((a, b) => a.timestamp - b.timestamp)[0];
+            if (oldest) {
+                failures.delete(oldest.id);
+            }
+        }
+        failures.set(id, record);
+        // Update pattern frequency
+        const existingPattern = patterns.get(errorType);
+        if (existingPattern) {
+            existingPattern.frequency++;
+        }
+        else {
+            patterns.set(errorType, {
+                pattern: errorType,
+                frequency: 1,
+                averageCorrectionTime: 0,
+                successRate: 0,
+            });
+        }
+        return record;
+    }
+    function getCounterfactual(failureId) {
+        const failure = failures.get(failureId);
+        return failure?.counterfactual || 'No counterfactual available';
+    }
+    function updatePattern(failureId, success) {
+        const failure = failures.get(failureId);
+        if (!failure)
+            return;
+        failure.resolved = success;
+        // Update pattern success rate
+        const pattern = patterns.get(failure.errorType);
+        if (pattern) {
+            const total = pattern.frequency;
+            const currentSuccesses = pattern.successRate * (total - 1);
+            pattern.successRate = (currentSuccesses + (success ? 1 : 0)) / total;
+        }
+        // Add lesson if successful recovery
+        if (success) {
+            const lesson = `For ${failure.errorType}: ${failure.counterfactual}`;
+            if (!failure.lessons.includes(lesson)) {
+                failure.lessons.push(lesson);
+            }
+        }
+    }
+    function getErrorPatterns() {
+        return Array.from(patterns.values())
+            .sort((a, b) => b.frequency - a.frequency);
+    }
+    async function recoverFromError(error, context) {
+        const errorType = extractErrorType(error, context);
+        const pattern = patterns.get(errorType);
+        // Check if this is a known pattern
+        if (pattern && pattern.frequency >= PATTERN_THRESHOLD && pattern.successRate > 0.5) {
+            return {
+                recovered: true,
+                attempts: 1,
+                finalStrategy: `Known pattern: ${pattern.suggestedFix || 'Use previously successful approach'}`,
+                lessonsLearned: [`Known error type: ${errorType}`, `Success rate: ${(pattern.successRate * 100).toFixed(0)}%`],
+            };
+        }
+        // Try counterfactual-based recovery
+        const failure = recordFailure(error, context, 'recovery_attempt', 'in_progress');
+        let attempts = 0;
+        const maxAttempts = 3;
+        while (attempts < maxAttempts) {
+            attempts++;
+            // Strategy 1: Check lesson bank
+            const lessonStrategy = `Check lesson bank for ${errorType} patterns`;
+            // Strategy 2: Use self-verification
+            const verifyStrategy = 'Run self-verification before retrying';
+            // Strategy 3: Slow down (PSO insight)
+            const slowStrategy = 'Wait and re-analyze before retrying';
+            // Simulate recovery attempt
+            const recovered = Math.random() > 0.3; // 70% success rate per attempt
+            if (recovered) {
+                updatePattern(failure.id, true);
+                return {
+                    recovered: true,
+                    attempts,
+                    finalStrategy: attempts === 1 ? lessonStrategy : attempts === 2 ? verifyStrategy : slowStrategy,
+                    lessonsLearned: [`Recovery attempt ${attempts} succeeded`],
+                };
+            }
+        }
+        updatePattern(failure.id, false);
+        return {
+            recovered: false,
+            attempts,
+            finalStrategy: 'All recovery attempts failed - manual intervention required',
+            lessonsLearned: ['Failed to recover automatically', 'Consider adding new lesson for this error type'],
+        };
+    }
+    function getStats() {
+        const totalFailures = failures.size;
+        const recoveredFailures = Array.from(failures.values()).filter(f => f.resolved).length;
+        const patternsLearned = patterns.size;
+        return {
+            totalFailures,
+            recoveredFailures,
+            patternsLearned,
+            recoveryRate: totalFailures > 0 ? recoveredFailures / totalFailures : 0,
+        };
+    }
+    return {
+        recordFailure,
+        getCounterfactual,
+        updatePattern,
+        getErrorPatterns,
+        recoverFromError,
+        getStats,
+    };
+}

package/dist/core/cognition/meta-agent.js

@@ -0,0 +1,407 @@
+/**
+ * MetaAgent - Self-Evolving Agent with Meta-Learning
+ *
+ * Paper: "MetaAgent: Self-Evolving Agent with Meta-Learning"
+ *
+ * Key concepts:
+ * - Meta-Learning: Learning to learn, not just learning specific tasks
+ * - Cross-domain knowledge transfer: Knowledge learned in one domain helps in another
+ * - Three-level optimization:
+ *   1. Environment-specific: Rapid adaptation to specific tasks
+ *   2. Cross-domain: Transfer knowledge across domains
+ *   3. Meta-knowledge: Abstract principles that accelerate learning
+ *
+ * Meta-knowledge structure:
+ * - Task schemas: Abstract task representations
+ * - Strategy patterns: Reusable problem-solving approaches
+ * - Domain mappings: How knowledge transfers between domains
+ */
+import { randomUUID } from 'crypto';
+const META_KNOWLEDGE_KEY = 'meta-knowledge';
+export function createMetaLearningEngine() {
+    let state = {
+        tasks: [],
+        schemas: new Map(),
+        strategies: new Map(),
+        domainMappings: new Map(),
+        crossDomainKnowledge: new Map(),
+        stats: {
+            totalTasks: 0,
+            successfulTransfers: 0,
+            failedTransfers: 0,
+            avgAdaptationTime: 0,
+            schemasLearned: 0,
+            strategiesDiscovered: 0,
+            crossDomainTransfers: 0,
+        },
+    };
+    function findDomainKey(domain) {
+        return domain.toLowerCase().split(/[\s_-]/)[0];
+    }
+    function findOrCreateSchema(task, domain) {
+        const domainKey = findDomainKey(domain);
+        // Look for existing similar schema
+        for (const schema of state.schemas.values()) {
+            if (findDomainKey(schema.domain) === domainKey) {
+                // Check similarity
+                const taskWords = new Set(task.toLowerCase().split(/\s+/).filter(w => w.length > 3));
+                const schemaWords = new Set(schema.abstractStructure.toLowerCase().split(/\s+/).filter(w => w.length > 3));
+                const intersection = [...taskWords].filter(w => schemaWords.has(w)).length;
+                if (intersection > taskWords.size * 0.3) {
+                    return schema;
+                }
+            }
+        }
+        // Create new schema
+        const schema = {
+            id: randomUUID(),
+            name: task.slice(0, 50),
+            domain,
+            abstractStructure: task,
+            keyParameters: task.split(/\s+/).filter(w => w.length > 4).slice(0, 10),
+            difficulty: 0.5,
+            successRate: 0.5,
+            lastUsed: Date.now(),
+        };
+        state.schemas.set(schema.id, schema);
+        state.stats.schemasLearned++;
+        return schema;
+    }
+    function findOrCreateStrategy(task, schemaIds) {
+        // Look for existing strategy that works for these schemas
+        for (const strategy of state.strategies.values()) {
+            if (strategy.applicableSchemas.some(id => schemaIds.includes(id))) {
+                return strategy;
+            }
+        }
+        // Create new strategy based on task
+        const steps = extractStepsFromTask(task);
+        const strategy = {
+            id: randomUUID(),
+            name: `Strategy-${Date.now()}`,
+            description: `Strategy for: ${task.slice(0, 50)}...`,
+            applicableSchemas: schemaIds,
+            steps,
+            successRate: 0.5,
+            avgDuration: 5000,
+            conditions: extractConditions(task),
+        };
+        state.strategies.set(strategy.id, strategy);
+        state.stats.strategiesDiscovered++;
+        return strategy;
+    }
+    function extractStepsFromTask(task) {
+        // Extract abstract steps from task description
+        const commonSteps = [
+            'analyze_requirements',
+            'plan_approach',
+            'execute_step_1',
+            'execute_step_2',
+            'verify_result',
+            'iterate_if_needed',
+        ];
+        // Simple extraction based on keywords
+        const steps = [];
+        const taskLower = task.toLowerCase();
+        if (taskLower.includes('search') || taskLower.includes('find')) {
+            steps.push('search_phase');
+        }
+        if (taskLower.includes('read') || taskLower.includes('analyze')) {
+            steps.push('analysis_phase');
+        }
+        if (taskLower.includes('write') || taskLower.includes('create') || taskLower.includes('build')) {
+            steps.push('creation_phase');
+        }
+        if (taskLower.includes('verify') || taskLower.includes('check') || taskLower.includes('test')) {
+            steps.push('verification_phase');
+        }
+        if (taskLower.includes('fix') || taskLower.includes('error') || taskLower.includes('bug')) {
+            steps.push('debugging_phase');
+        }
+        return steps.length > 0 ? steps : commonSteps;
+    }
+    function extractConditions(task) {
+        const conditions = [];
+        const taskLower = task.toLowerCase();
+        if (taskLower.includes('complex') || taskLower.includes('difficult')) {
+            conditions.push('high_complexity');
+        }
+        if (taskLower.includes('simple') || taskLower.includes('easy')) {
+            conditions.push('low_complexity');
+        }
+        if (taskLower.includes('urgent') || taskLower.includes('quick')) {
+            conditions.push('time_critical');
+        }
+        if (taskLower.includes('new') || taskLower.includes('first')) {
+            conditions.push('exploration_phase');
+        }
+        if (taskLower.includes('repeat') || taskLower.includes('again')) {
+            conditions.push('exploitation_phase');
+        }
+        return conditions;
+    }
+    function findDomainMapping(sourceDomain, targetDomain) {
+        const sourceKey = findDomainKey(sourceDomain);
+        const targetKey = findDomainKey(targetDomain);
+        const mapKey = `${sourceKey}->${targetKey}`;
+        return state.domainMappings.get(mapKey);
+    }
+    function createDomainMapping(sourceDomain, targetDomain) {
+        const sourceKey = findDomainKey(sourceDomain);
+        const targetKey = findDomainKey(targetDomain);
+        const mapKey = `${sourceKey}->${targetKey}`;
+        // Find transferable concepts (words that appear in both domains)
+        const sourceWords = new Set(sourceDomain.toLowerCase().split(/\s+/));
+        const targetWords = new Set(targetDomain.toLowerCase().split(/\s+/));
+        const transferable = [...sourceWords].filter(w => targetWords.has(w) && w.length > 3);
+        const mapping = {
+            sourceDomain,
+            targetDomain,
+            transferableConcepts: transferable.length > 0 ? transferable : ['general_concept'],
+            transfer成功率: 0.5,
+            usageCount: 0,
+        };
+        state.domainMappings.set(mapKey, mapping);
+        // Update cross-domain knowledge
+        if (!state.crossDomainKnowledge.has(sourceKey)) {
+            state.crossDomainKnowledge.set(sourceKey, new Set());
+        }
+        state.crossDomainKnowledge.get(sourceKey).add(targetKey);
+        return mapping;
+    }
+    function learnFromTask(task, domain, success, feedback) {
+        const startTime = Date.now();
+        state.stats.totalTasks++;
+        // Record task
+        state.tasks.push({ task, domain, success, timestamp: Date.now() });
+        if (state.tasks.length > 100) {
+            state.tasks = state.tasks.slice(-100);
+        }
+        // Find or create schema
+        const schema = findOrCreateSchema(task, domain);
+        // Update schema success rate
+        const prevSuccess = schema.successRate;
+        schema.successRate = prevSuccess * 0.9 + (success ? 0.1 : 0);
+        schema.lastUsed = Date.now();
+        // Find or create strategy
+        const strategy = findOrCreateStrategy(task, [schema.id]);
+        // Update strategy success rate
+        if (success) {
+            strategy.successRate = strategy.successRate * 0.95 + 0.05;
+            state.stats.successfulTransfers++;
+        }
+        else {
+            strategy.successRate = strategy.successRate * 0.9;
+            state.stats.failedTransfers++;
+        }
+        // Check for cross-domain knowledge transfer
+        let transferredKnowledge;
+        const recentSameDomain = state.tasks
+            .filter(t => findDomainKey(t.domain) === findDomainKey(domain) && t !== state.tasks[state.tasks.length - 1])
+            .slice(-5);
+        if (recentSameDomain.length > 0 && !success) {
+            // Try to find successful approach from related tasks
+            const successfulTasks = recentSameDomain.filter(t => t.success);
+            if (successfulTasks.length > 0) {
+                transferredKnowledge = successfulTasks.map(t => t.task);
+                state.stats.crossDomainTransfers++;
+            }
+        }
+        const adaptationTime = Date.now() - startTime;
+        state.stats.avgAdaptationTime =
+            (state.stats.avgAdaptationTime * (state.stats.totalTasks - 1) + adaptationTime) / state.stats.totalTasks;
+        return {
+            adapted: true,
+            metaLevel: transferredKnowledge ? 'cross_domain' : 'environment_specific',
+            usedSchema: schema.id,
+            usedStrategy: strategy.id,
+            transferredKnowledge,
+            adaptationTime,
+            confidence: schema.successRate * strategy.successRate,
+        };
+    }
+    function selectBestStrategy(task, domain) {
+        const domainKey = findDomainKey(domain);
+        const taskConditions = extractConditions(task);
+        // Find all strategies applicable to this domain
+        const applicableStrategies = [];
+        for (const strategy of state.strategies.values()) {
+            const appliesToDomain = strategy.applicableSchemas.some(id => {
+                const schema = state.schemas.get(id);
+                return schema && findDomainKey(schema.domain) === domainKey;
+            });
+            if (!appliesToDomain)
+                continue;
+            // Score based on success rate and condition match
+            let score = strategy.successRate * 0.7;
+            // Bonus for condition match
+            const conditionMatch = strategy.conditions.filter(c => taskConditions.includes(c)).length;
+            score += conditionMatch * 0.1;
+            // Recency bonus
+            const timeSinceUse = Date.now() - strategy.avgDuration;
+            if (timeSinceUse < 60000) {
+                score += 0.1;
+            }
+            applicableStrategies.push({ strategy, score });
+        }
+        // Sort by score
+        applicableStrategies.sort((a, b) => b.score - a.score);
+        if (applicableStrategies.length === 0) {
+            // Create default strategy
+            const defaultStrategy = {
+                id: 'default',
+                name: 'Default Strategy',
+                description: 'Fallback strategy',
+                applicableSchemas: [],
+                steps: extractStepsFromTask(task),
+                successRate: 0.5,
+                avgDuration: 5000,
+                conditions: [],
+            };
+            return {
+                strategy: defaultStrategy,
+                confidence: 0.5,
+                alternativeStrategies: [],
+            };
+        }
+        return {
+            strategy: applicableStrategies[0].strategy,
+            confidence: applicableStrategies[0].score,
+            alternativeStrategies: applicableStrategies.slice(1, 4).map(s => s.strategy),
+        };
+    }
+    function transferKnowledge(sourceDomain, targetDomain, task) {
+        const sourceKey = findDomainKey(sourceDomain);
+        const targetKey = findDomainKey(targetDomain);
+        // Find or create mapping
+        let mapping = findDomainMapping(sourceDomain, targetDomain);
+        if (!mapping) {
+            mapping = createDomainMapping(sourceDomain, targetDomain);
+        }
+        mapping.usageCount++;
+        // Get schemas from source domain
+        const sourceSchemas = Array.from(state.schemas.values()).filter(s => findDomainKey(s.domain) === sourceKey);
+        // Get strategies from source domain
+        const sourceStrategies = Array.from(state.strategies.values()).filter(s => s.applicableSchemas.some(id => sourceSchemas.some(ss => ss.id === id)));
+        // Find relevant strategies for the task
+        const taskWords = new Set(task.toLowerCase().split(/\s+/).filter(w => w.length > 3));
+        const relevantStrategies = [];
+        for (const strategy of sourceStrategies) {
+            const strategyWords = new Set(strategy.description.toLowerCase().split(/\s+/));
+            const overlap = [...taskWords].filter(w => strategyWords.has(w)).length;
+            if (overlap > 0) {
+                relevantStrategies.push(strategy.description);
+            }
+        }
+        return relevantStrategies.length > 0 ? relevantStrategies : mapping.transferableConcepts;
+    }
+    function registerSchema(schema) {
+        state.schemas.set(schema.id, schema);
+    }
+    function getSchema(id) {
+        return state.schemas.get(id);
+    }
+    function findSimilarSchemas(task, domain) {
+        const taskWords = new Set(task.toLowerCase().split(/\s+/).filter(w => w.length > 3));
+        const results = [];
+        for (const schema of state.schemas.values()) {
+            if (domain && findDomainKey(schema.domain) !== findDomainKey(domain)) {
+                continue;
+            }
+            const schemaWords = new Set(schema.abstractStructure.toLowerCase().split(/\s+/).filter(w => w.length > 3));
+            const intersection = [...taskWords].filter(w => schemaWords.has(w)).length;
+            const union = taskWords.size + schemaWords.size - intersection;
+            const similarity = union > 0 ? intersection / union : 0;
+            if (similarity > 0.2) {
+                results.push({ schema, similarity });
+            }
+        }
+        return results.sort((a, b) => b.similarity - a.similarity).map(r => r.schema);
+    }
+    function registerStrategy(strategy) {
+        state.strategies.set(strategy.id, strategy);
+    }
+    function getStrategy(id) {
+        return state.strategies.get(id);
+    }
+    function improveStrategy(strategyId, improvement) {
+        const strategy = state.strategies.get(strategyId);
+        if (strategy) {
+            strategy.description += ` | Improved: ${improvement}`;
+            strategy.successRate = Math.min(1, strategy.successRate + 0.05);
+        }
+    }
+    function addDomainMapping(source, target, concepts) {
+        const sourceKey = findDomainKey(source);
+        const targetKey = findDomainKey(target);
+        const mapKey = `${sourceKey}->${targetKey}`;
+        state.domainMappings.set(mapKey, {
+            sourceDomain: source,
+            targetDomain: target,
+            transferableConcepts: concepts,
+            transfer成功率: 0.6,
+            usageCount: 0,
+        });
+    }
+    function getRelatedDomains(domain) {
+        const domainKey = findDomainKey(domain);
+        const related = state.crossDomainKnowledge.get(domainKey);
+        return related ? [...related] : [];
+    }
+    function getMetaKnowledge() {
+        return {
+            schemas: new Map(state.schemas),
+            strategies: new Map(state.strategies),
+            domainMappings: new Map(state.domainMappings),
+            crossDomainKnowledge: new Map([...state.crossDomainKnowledge.entries()].map(([k, v]) => [k, [...v]])),
+        };
+    }
+    function exportMetaKnowledge() {
+        return JSON.stringify({
+            schemas: Array.from(state.schemas.entries()),
+            strategies: Array.from(state.strategies.entries()),
+            domainMappings: Array.from(state.domainMappings.entries()),
+            crossDomainKnowledge: [...state.crossDomainKnowledge.entries()].map(([k, v]) => [k, [...v]]),
+        });
+    }
+    function importMetaKnowledge(data) {
+        try {
+            const parsed = JSON.parse(data);
+            if (parsed.schemas) {
+                state.schemas = new Map(parsed.schemas);
+            }
+            if (parsed.strategies) {
+                state.strategies = new Map(parsed.strategies);
+            }
+            if (parsed.domainMappings) {
+                state.domainMappings = new Map(parsed.domainMappings);
+            }
+            if (parsed.crossDomainKnowledge) {
+                state.crossDomainKnowledge = new Map(parsed.crossDomainKnowledge.map(([k, v]) => [k, new Set(v)]));
+            }
+        }
+        catch {
+            // Invalid data, ignore
+        }
+    }
+    function getStats() {
+        return { ...state.stats };
+    }
+    return {
+        learnFromTask,
+        selectBestStrategy,
+        transferKnowledge,
+        registerSchema,
+        getSchema,
+        findSimilarSchemas,
+        registerStrategy,
+        getStrategy,
+        improveStrategy,
+        addDomainMapping,
+        getRelatedDomains,
+        getMetaKnowledge,
+        exportMetaKnowledge,
+        importMetaKnowledge,
+        getStats,
+    };
+}