mark-improving-agent 2.2.0

package/dist/core/evolution/goal-engine.js

@@ -0,0 +1,153 @@
+import { randomUUID } from 'crypto';
+import { readFileSync, writeFileSync, mkdirSync, existsSync } from 'fs';
+import { join, dirname } from 'path';
+const KEYWORD_MAP = {
+    '理解': 'understanding',
+    '成长': 'growth',
+    '共情': 'empathy',
+    '反思': 'reflection',
+    '真相': 'truth_seeking',
+};
+const PRIORITY_KEYWORDS = {
+    '重要': 'high',
+    '紧急': 'high',
+    '必须': 'high',
+    '可能': 'medium',
+    '应该': 'medium',
+    '可以': 'low',
+    '也许': 'low',
+};
+function classifyGoalType(input) {
+    for (const [keyword, type] of Object.entries(KEYWORD_MAP)) {
+        if (input.includes(keyword)) {
+            return type;
+        }
+    }
+    return 'growth';
+}
+function classifyPriority(input) {
+    for (const [keyword, priority] of Object.entries(PRIORITY_KEYWORDS)) {
+        if (input.includes(keyword)) {
+            return priority;
+        }
+    }
+    return 'medium';
+}
+function atomicWrite(filePath, data) {
+    const tmp = filePath + '.tmp.' + randomUUID().slice(0, 8);
+    writeFileSync(tmp, data, 'utf-8');
+    const fs = require('fs');
+    fs.renameSync(tmp, filePath);
+}
+function ensureDir(dir) {
+    if (!existsSync(dir)) {
+        mkdirSync(dir, { recursive: true });
+    }
+}
+export function createGoalEngine(dataDir) {
+    let goals = [];
+    let stateLoaded = false;
+    const filePath = join(dataDir, 'goals.json');
+    async function persist() {
+        ensureDir(dirname(filePath));
+        atomicWrite(filePath, JSON.stringify({ goals }, null, 2));
+    }
+    async function boot() {
+        if (existsSync(filePath)) {
+            try {
+                const raw = readFileSync(filePath, 'utf-8');
+                const state = JSON.parse(raw);
+                goals = (state.goals || []).filter(isValidGoal);
+                stateLoaded = true;
+            }
+            catch {
+                goals = [];
+                stateLoaded = true;
+            }
+        }
+        else {
+            goals = [];
+            stateLoaded = true;
+        }
+    }
+    function isValidGoal(obj) {
+        if (typeof obj !== 'object' || obj === null)
+            return false;
+        const g = obj;
+        return (typeof g.id === 'string' &&
+            ['understanding', 'growth', 'empathy', 'reflection', 'truth_seeking'].includes(g.type) &&
+            ['high', 'medium', 'low'].includes(g.priority) &&
+            typeof g.description === 'string' &&
+            typeof g.criteria === 'string' &&
+            ['pending', 'active', 'completed', 'failed'].includes(g.status) &&
+            typeof g.createdAt === 'number');
+    }
+    function generateGoals(input) {
+        const activeGoals = goals.filter(g => g.status === 'active' || g.status === 'pending');
+        if (activeGoals.length >= 10) {
+            return [];
+        }
+        const type = classifyGoalType(input);
+        const priority = classifyPriority(input);
+        const lines = input.split(/[。\n]+/).filter(s => s.trim().length > 5);
+        const generated = [];
+        for (const line of lines.slice(0, 3)) {
+            const trimmed = line.trim();
+            if (trimmed.length === 0)
+                continue;
+            const goal = {
+                id: randomUUID(),
+                type,
+                priority,
+                description: trimmed,
+                criteria: `Achieve understanding of: ${trimmed.slice(0, 50)}`,
+                status: 'pending',
+                createdAt: Date.now(),
+            };
+            generated.push(goal);
+            goals.push(goal);
+        }
+        return generated;
+    }
+    function getActiveGoals() {
+        return goals.filter(g => g.status === 'active' || g.status === 'pending');
+    }
+    function completeGoal(id) {
+        const goal = goals.find(g => g.id === id);
+        if (goal) {
+            goal.status = 'completed';
+            goal.completedAt = Date.now();
+        }
+    }
+    function failGoal(id) {
+        const goal = goals.find(g => g.id === id);
+        if (goal) {
+            goal.status = 'failed';
+            goal.completedAt = Date.now();
+        }
+    }
+    function updateGoalStatus(id, status) {
+        const goal = goals.find(g => g.id === id);
+        if (goal) {
+            goal.status = status;
+        }
+    }
+    function getStats() {
+        return {
+            pending: goals.filter(g => g.status === 'pending').length,
+            active: goals.filter(g => g.status === 'active').length,
+            completed: goals.filter(g => g.status === 'completed').length,
+            failed: goals.filter(g => g.status === 'failed').length,
+        };
+    }
+    return {
+        generateGoals,
+        getActiveGoals,
+        completeGoal,
+        failGoal,
+        updateGoalStatus,
+        getStats,
+        persist,
+        boot,
+    };
+}

package/dist/core/evolution/index.js

@@ -0,0 +1,6 @@
+export * from './types.js';
+export * from './goal-engine.js';
+export * from './meta-learning.js';
+export * from './reflection.js';
+export * from './self-healer.js';
+export * from './engine.js';

package/dist/core/evolution/meta-learning.js

@@ -0,0 +1,172 @@
+import { randomUUID } from 'crypto';
+import { readFileSync, writeFileSync, existsSync } from 'fs';
+import { join, dirname } from 'path';
+const STRATEGY_KEYWORDS = {
+    conceptual: ['概念', '理论', '原理', '本质', '定义'],
+    example: ['例子', '示例', '案例', '实例', '例如'],
+    analogy: ['类比', '比喻', '相似', '如同', '犹如'],
+    step_by_step: ['步骤', '过程', '阶段', '依次', '逐步'],
+    socratic: ['为什么', '为何', '原因', '理由', '怎样'],
+};
+const ALPHA = 0.3;
+const DEFAULT_SCORE = 50.0;
+function atomicWrite(filePath, data) {
+    const tmp = filePath + '.tmp.' + randomUUID().slice(0, 8);
+    writeFileSync(tmp, data, 'utf-8');
+    const fs = require('fs');
+    fs.renameSync(tmp, filePath);
+}
+function ensureDir(dir) {
+    const fs = require('fs');
+    if (!existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+    }
+}
+function createInitialQTable() {
+    return {
+        conceptual: { score: DEFAULT_SCORE, uses: 0 },
+        example: { score: DEFAULT_SCORE, uses: 0 },
+        analogy: { score: DEFAULT_SCORE, uses: 0 },
+        step_by_step: { score: DEFAULT_SCORE, uses: 0 },
+        socratic: { score: DEFAULT_SCORE, uses: 0 },
+    };
+}
+function classifyByKeywords(input) {
+    const scores = new Map();
+    for (const [strategy, keywords] of Object.entries(STRATEGY_KEYWORDS)) {
+        let count = 0;
+        for (const kw of keywords) {
+            if (input.includes(kw))
+                count++;
+        }
+        scores.set(strategy, count);
+    }
+    return scores;
+}
+function selectBestStrategy(scores) {
+    let best = 'conceptual';
+    let maxScore = -1;
+    for (const [strategy, score] of scores) {
+        if (score > maxScore) {
+            maxScore = score;
+            best = strategy;
+        }
+    }
+    return best;
+}
+export function createMetaLearner(dataDir) {
+    let qtable = createInitialQTable();
+    let stateLoaded = false;
+    let booted = false;
+    const filePath = join(dataDir, 'qtable.json');
+    function totalUses() {
+        return Object.values(qtable).reduce((s, v) => s + v.uses, 0);
+    }
+    async function persist() {
+        if (!booted)
+            return;
+        ensureDir(dirname(filePath));
+        atomicWrite(filePath, JSON.stringify({ qtable }, null, 2));
+    }
+    async function boot() {
+        if (existsSync(filePath)) {
+            try {
+                const raw = readFileSync(filePath, 'utf-8');
+                const parsed = JSON.parse(raw);
+                if (parsed.qtable) {
+                    qtable = validateQTable(parsed.qtable);
+                }
+            }
+            catch {
+                qtable = createInitialQTable();
+            }
+        }
+        booted = true;
+        stateLoaded = true;
+    }
+    function validateQTable(raw) {
+        const base = createInitialQTable();
+        if (typeof raw !== 'object' || raw === null)
+            return base;
+        const table = raw;
+        for (const key of Object.keys(base)) {
+            if (table[key] && typeof table[key] === 'object' && table[key] !== null) {
+                const entry = table[key];
+                if (typeof entry.score === 'number')
+                    base[key].score = entry.score;
+                if (typeof entry.uses === 'number')
+                    base[key].uses = entry.uses;
+            }
+        }
+        return base;
+    }
+    function selectStrategy(input) {
+        const scores = classifyByKeywords(input);
+        const strategy = selectBestStrategy(scores);
+        const hits = scores.get(strategy) || 0;
+        const confidence = Math.min(1, (hits + 1) / 4);
+        return { strategy, confidence };
+    }
+    async function learn(input, strategy) {
+        const sentences = input.split(/[。！？\n]+/).filter(s => s.trim().length > 0);
+        const concepts = [];
+        const meaningfulSentences = [];
+        const conceptKeywords = ['是', '为', '指', '表示', '代表', '意味着'];
+        for (const sent of sentences) {
+            const trimmed = sent.trim();
+            if (trimmed.length < 4)
+                continue;
+            let foundConcept = false;
+            for (const kw of conceptKeywords) {
+                if (trimmed.includes(kw)) {
+                    const parts = trimmed.split(kw);
+                    if (parts[0] && parts[0].trim().length > 1) {
+                        concepts.push(parts[0].trim().slice(-20));
+                        foundConcept = true;
+                    }
+                }
+            }
+            if (!foundConcept && trimmed.length > 5) {
+                meaningfulSentences.push(trimmed.slice(0, 40));
+            }
+        }
+        const uniqueConcepts = [...new Set(concepts)].slice(0, 10);
+        if (uniqueConcepts.length === 0 && meaningfulSentences.length > 0) {
+            for (const s of meaningfulSentences.slice(0, 5)) {
+                if (s.length > 4)
+                    uniqueConcepts.push(s.slice(0, 20));
+            }
+        }
+        const quality = uniqueConcepts.length >= 5 ? 'high' :
+            uniqueConcepts.length >= 2 ? 'medium' : 'low';
+        const summary = meaningfulSentences.length > 0
+            ? meaningfulSentences.slice(0, 3).join('; ')
+            : input.slice(0, 100);
+        return {
+            summary,
+            concepts: uniqueConcepts,
+            quality,
+        };
+    }
+    function recordOutcome(strategy, success) {
+        const entry = qtable[strategy];
+        entry.uses += 1;
+        const delta = success ? 10 : -5;
+        entry.score = entry.score + ALPHA * delta;
+        if (entry.score < 0)
+            entry.score = 0;
+        if (entry.score > 100)
+            entry.score = 100;
+    }
+    function getStrategyScores() {
+        return { ...qtable };
+    }
+    return {
+        selectStrategy,
+        learn,
+        recordOutcome,
+        getStrategyScores,
+        persist,
+        boot,
+    };
+}

package/dist/core/evolution/reflection.js

@@ -0,0 +1,158 @@
+import { randomUUID } from 'crypto';
+import { writeFileSync, existsSync } from 'fs';
+import { join, dirname } from 'path';
+const MAX_INSIGHTS = 200;
+const PATTERN_KEYWORDS = {
+    pattern: ['重复', '规律', '循环', '一直', '总是'],
+    connection: ['关联', '联系', '因此', '所以', '导致'],
+    decay: ['遗忘', '衰退', '模糊', '淡忘', '减弱'],
+    correction: ['纠正', '修正', '调整', '改进', '弥补'],
+    breakthrough: ['突破', '顿悟', '发现', '领悟', '觉醒'],
+};
+function atomicWrite(filePath, data) {
+    const tmp = filePath + '.tmp.' + randomUUID().slice(0, 8);
+    writeFileSync(tmp, data, 'utf-8');
+    const fs = require('fs');
+    fs.renameSync(tmp, filePath);
+}
+function ensureDir(dir) {
+    const fs = require('fs');
+    if (!existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+    }
+}
+function classifyInsightType(text) {
+    for (const [type, keywords] of Object.entries(PATTERN_KEYWORDS)) {
+        for (const kw of keywords) {
+            if (text.includes(kw)) {
+                return type;
+            }
+        }
+    }
+    return 'pattern';
+}
+function extractInsightDescription(line) {
+    const cleaned = line.trim();
+    if (cleaned.length > 60)
+        return cleaned.slice(0, 57) + '...';
+    return cleaned;
+}
+function detectErrors(input, learning) {
+    const errors = [];
+    if (learning.concepts.length === 0) {
+        errors.push('No concepts extracted from input');
+    }
+    if (learning.quality === 'low') {
+        errors.push('Learning quality is low');
+    }
+    if (input.length < 10) {
+        errors.push('Input too short for meaningful reflection');
+    }
+    const contradictory = /(?:但是|然而|不过|却)/;
+    if (contradictory.test(input)) {
+        errors.push('Contradictory patterns detected in input');
+    }
+    return errors;
+}
+function generateRecommendation(errors, insights) {
+    if (errors.length > 0) {
+        return 'Review input for clarity and ensure sufficient context for learning.';
+    }
+    if (insights.length === 0) {
+        return 'Continue learning to generate more insights.';
+    }
+    const highWeight = insights.filter(i => i.weight > 0.7);
+    if (highWeight.length > 0) {
+        return 'High-value insights detected. Prioritize actionable items.';
+    }
+    return 'Maintain current learning approach.';
+}
+function createInitialState() {
+    return {
+        insights: [],
+        introspectionErrors: [],
+        introspectionBlindSpots: [],
+    };
+}
+export function createReflector(dataDir) {
+    let state = createInitialState();
+    let booted = false;
+    const filePath = join(dataDir, 'insights.json');
+    async function persist() {
+        if (!booted)
+            return;
+        ensureDir(dirname(filePath));
+        atomicWrite(filePath, JSON.stringify({ insights: state.insights }, null, 2));
+    }
+    function reflect(input, learning, context) {
+        const lines = input.split(/[。！？\n]+/).filter(s => s.trim().length > 5);
+        const errorsDetected = detectErrors(input, learning);
+        const newInsights = [];
+        for (const line of lines.slice(0, 5)) {
+            const trimmed = line.trim();
+            if (trimmed.length < 4)
+                continue;
+            const insightType = classifyInsightType(trimmed);
+            let weight = 0.5;
+            if (learning.quality === 'high')
+                weight += 0.2;
+            if (learning.concepts.some(c => trimmed.includes(c)))
+                weight += 0.1;
+            weight = Math.min(1, Math.max(0.1, weight));
+            const insight = {
+                type: insightType,
+                description: extractInsightDescription(trimmed),
+                weight,
+                actionable: insightType === 'correction' ? 'Review and adjust approach' : undefined,
+            };
+            newInsights.push(insight);
+        }
+        if (newInsights.length === 0 && input.length > 10) {
+            const fallbackInsight = {
+                type: 'pattern',
+                description: input.slice(0, 60) + (input.length > 60 ? '...' : ''),
+                weight: 0.5,
+            };
+            newInsights.push(fallbackInsight);
+        }
+        for (const insight of newInsights) {
+            const exists = state.insights.some(i => i.description === insight.description && i.type === insight.type);
+            if (!exists) {
+                state.insights.push(insight);
+            }
+        }
+        while (state.insights.length > MAX_INSIGHTS) {
+            state.insights.shift();
+        }
+        const quality = errorsDetected.length > 0 ? 'needs_improvement' : 'good';
+        const recommendation = generateRecommendation(errorsDetected, state.insights);
+        return {
+            insights: [...newInsights],
+            quality,
+            errorsDetected,
+            recommendation,
+        };
+    }
+    function recordIntrospection(errors, blindSpots) {
+        state.introspectionErrors.push(...errors);
+        state.introspectionBlindSpots.push(...blindSpots);
+        if (state.introspectionErrors.length > 50) {
+            state.introspectionErrors = state.introspectionErrors.slice(-50);
+        }
+        if (state.introspectionBlindSpots.length > 50) {
+            state.introspectionBlindSpots = state.introspectionBlindSpots.slice(-50);
+        }
+    }
+    function getInsights(limit) {
+        const sorted = [...state.insights].sort((a, b) => b.weight - a.weight);
+        if (limit !== undefined && limit > 0) {
+            return sorted.slice(0, limit);
+        }
+        return sorted;
+    }
+    return {
+        reflect,
+        recordIntrospection,
+        getInsights,
+    };
+}

package/dist/core/evolution/self-healer.js

@@ -0,0 +1,139 @@
+const EPSILON = 0.1;
+const ALPHA = 0.3;
+const PATTERN_KEYWORDS = {
+    timeout: ['timeout', 'timed out', 'ETIMEDOUT', 'TIMEOUT'],
+    network: ['network', 'ENOTFOUND', 'ECONNREFUSED', 'connection'],
+    memory: ['memory', 'heap', 'out of memory', 'OOM'],
+    permission: ['permission', 'EPERM', 'EACCES', 'denied'],
+    syntax: ['syntax', 'parse', 'invalid', 'malformed'],
+    reference: ['not found', 'undefined', 'null', 'cannot read'],
+    type: ['type', 'instanceof', 'expected'],
+};
+const BACKOFF_MS = {
+    retry: 1000,
+    fallback: 5000,
+    skip: 0,
+    abort: 0,
+};
+const DEFAULT_Q = { qValue: 50.0, uses: 0 };
+const STRATEGIES = ['retry', 'fallback', 'skip', 'abort'];
+function detectPattern(error) {
+    const msg = String(error.message || error.msg || '').toLowerCase();
+    for (const [pattern, keywords] of Object.entries(PATTERN_KEYWORDS)) {
+        for (const kw of keywords) {
+            if (msg.includes(kw.toLowerCase())) {
+                return pattern;
+            }
+        }
+    }
+    return 'unknown';
+}
+function getOrCreateStrategyMap(table, pattern) {
+    let map = table.get(pattern);
+    if (!map) {
+        map = new Map();
+        for (const s of STRATEGIES) {
+            map.set(s, { ...DEFAULT_Q });
+        }
+        table.set(pattern, map);
+    }
+    return map;
+}
+function selectStrategy(table, pattern) {
+    const map = getOrCreateStrategyMap(table, pattern);
+    const rand = Math.random();
+    if (rand < EPSILON) {
+        const idx = Math.floor(Math.random() * STRATEGIES.length);
+        return STRATEGIES[idx];
+    }
+    let best = 'retry';
+    let bestQ = -Infinity;
+    for (const s of STRATEGIES) {
+        const entry = map.get(s);
+        if (entry && entry.qValue > bestQ) {
+            bestQ = entry.qValue;
+            best = s;
+        }
+    }
+    return best;
+}
+export function createSelfHealer() {
+    const qtable = new Map();
+    const failureWindow = [];
+    const patternCounts = {};
+    let attemptCounter = 0;
+    function heal(error) {
+        const pattern = detectPattern(error);
+        const strategy = selectStrategy(qtable, pattern);
+        attemptCounter++;
+        const recent = failureWindow.slice(-20);
+        const recentFailures = recent.filter(p => p === pattern).length;
+        const hints = [];
+        switch (strategy) {
+            case 'retry':
+                hints.push('Re-attempt the failed operation');
+                hints.push(`Pattern: ${pattern}`);
+                break;
+            case 'fallback':
+                hints.push('Use alternative approach');
+                hints.push('Log current state for debugging');
+                break;
+            case 'skip':
+                hints.push('Skip problematic step');
+                hints.push('Continue with remaining steps');
+                break;
+            case 'abort':
+                hints.push('Stop execution');
+                hints.push('Report error to monitoring');
+                break;
+        }
+        if (pattern !== 'unknown') {
+            patternCounts[pattern] = (patternCounts[pattern] || 0) + 1;
+        }
+        return {
+            ok: strategy === 'skip' || strategy === 'abort',
+            attempt: attemptCounter,
+            canRetry: strategy === 'retry' || strategy === 'fallback',
+            backoffMs: BACKOFF_MS[strategy],
+            strategy,
+            hints,
+        };
+    }
+    function recordOutcome(strategy, success) {
+        const lastPattern = failureWindow[failureWindow.length - 1] || 'unknown';
+        const map = getOrCreateStrategyMap(qtable, lastPattern);
+        const entry = map.get(strategy);
+        if (entry) {
+            entry.uses += 1;
+            const delta = success ? 10 : -8;
+            entry.qValue = entry.qValue + ALPHA * delta;
+            if (entry.qValue < 0)
+                entry.qValue = 0;
+            if (entry.qValue > 100)
+                entry.qValue = 100;
+        }
+        if (!success) {
+            failureWindow.push(lastPattern);
+            if (failureWindow.length > 20) {
+                failureWindow.shift();
+            }
+        }
+    }
+    function getFailureStats() {
+        const recent = failureWindow.slice(-20);
+        return {
+            recentFailures: recent.length,
+            patterns: { ...patternCounts },
+        };
+    }
+    function clearFailureWindow() {
+        failureWindow.length = 0;
+        Object.keys(patternCounts).forEach(k => delete patternCounts[k]);
+    }
+    return {
+        heal,
+        recordOutcome,
+        getFailureStats,
+        clearFailureWindow,
+    };
+}

package/dist/core/evolution/types.js

@@ -0,0 +1 @@
+export {};