mark-improving-agent 2.2.0

package/dist/core/memory/adaptive-rag.js

@@ -0,0 +1,440 @@
+/**
+ * Adaptive RAG Memory (ARM)
+ *
+ * Paper: "ARM: Adaptive RAG Memory System for LLM Agents"
+ *
+ * Key mechanisms:
+ * 1. Query Classification: Classify query type to select optimal retrieval strategy
+ * 2. Dynamic Strategy Selection: Choose between semantic, keyword, graph, or hybrid
+ * 3. Iterative Refinement: Refine retrieval based on results
+ * 4. Memory-Aware: Use historical performance to guide retrieval
+ *
+ * Query types:
+ * - Factual: Who/What/When/Where
+ * - Analytical: Why/How (causal reasoning)
+ * - Exploratory: Open-ended discovery
+ * - Navigational: Find specific information
+ * - Transactional: Action-oriented tasks
+ */
+import { randomUUID } from 'crypto';
+const DEFAULT_CONFIG = {
+    enableRefinement: true,
+    maxRefinementIterations: 3,
+    relevanceThreshold: 0.6,
+    diversityWeight: 0.3,
+    recencyWeight: 0.2,
+};
+const QUERY_TYPE_PATTERNS = {
+    factual: {
+        patterns: [/谁|什么|哪个|多少|when|what|who|where|which/i],
+        weight: 0.9,
+    },
+    analytical: {
+        patterns: [/为什么|怎么|如何|why|how|原因|分析/i],
+        weight: 0.85,
+    },
+    exploratory: {
+        patterns: [/探索|发现|寻找|研究|discover|explore|find/i],
+        weight: 0.8,
+    },
+    navigational: {
+        patterns: [/查找|搜索|定位|navigate|search|find|locate/i],
+        weight: 0.75,
+    },
+    transactional: {
+        patterns: [/执行|完成|创建|删除|修改|do|execute|create|update|delete/i],
+        weight: 0.8,
+    },
+};
+const STRATEGY_PREFERENCES = {
+    factual: ['keyword', 'semantic', 'hybrid'],
+    analytical: ['semantic', 'graph', 'hybrid'],
+    exploratory: ['semantic', 'graph', 'hybrid'],
+    navigational: ['keyword', 'semantic'],
+    transactional: ['keyword', 'hybrid'],
+};
+export function createAdaptiveRAGMemory(config) {
+    const cfg = { ...DEFAULT_CONFIG, ...config };
+    // Memory storage
+    const memoryEntries = new Map();
+    // Query history for learning
+    const queryHistory = [];
+    // Strategy performance tracking
+    const strategyPerformance = new Map();
+    for (const s of ['semantic', 'keyword', 'graph', 'hybrid', 'adaptive']) {
+        strategyPerformance.set(s, { attempts: 0, successes: 0 });
+    }
+    // Cache for recent queries
+    const queryCache = new Map();
+    let stats = {
+        totalQueries: 0,
+        queriesByType: { factual: 0, analytical: 0, exploratory: 0, navigational: 0, transactional: 0 },
+        strategyUsage: { semantic: 0, keyword: 0, graph: 0, hybrid: 0, adaptive: 0 },
+        avgRefinementIterations: 0,
+        avgRetrievalTime: 0,
+        cacheHits: 0,
+        cacheMisses: 0,
+    };
+    function classifyQuery(query) {
+        const queryLower = query.toLowerCase();
+        const scores = {
+            factual: 0,
+            analytical: 0,
+            exploratory: 0,
+            navigational: 0,
+            transactional: 0,
+        };
+        // Pattern matching
+        for (const [type, { patterns, weight }] of Object.entries(QUERY_TYPE_PATTERNS)) {
+            for (const pattern of patterns) {
+                if (pattern.test(queryLower)) {
+                    scores[type] += weight;
+                }
+            }
+        }
+        // Score-based classification
+        const entries = Object.entries(scores);
+        entries.sort((a, b) => b[1] - a[1]);
+        const topType = entries[0][0];
+        const topScore = entries[0][1];
+        const secondScore = entries[1][1];
+        // Extract key entities (simplified)
+        const words = query.split(/\s+/).filter(w => w.length > 2);
+        const keyEntities = words.slice(0, 5);
+        // Calculate complexity based on query length and structure
+        const complexity = Math.min(1, (query.length / 200) + (words.length / 20));
+        return {
+            type: topScore > 0 ? topType : 'exploratory',
+            confidence: topScore / (topScore + secondScore + 0.1),
+            keyEntities,
+            complexity,
+        };
+    }
+    async function retrieve(query, options) {
+        const startTime = Date.now();
+        stats.totalQueries++;
+        // Check cache
+        const cacheKey = `${query}:${options?.strategy || 'adaptive'}`;
+        if (queryCache.has(cacheKey)) {
+            stats.cacheHits++;
+            return queryCache.get(cacheKey);
+        }
+        stats.cacheMisses++;
+        // Classify query
+        const classification = classifyQuery(query);
+        // Select strategy
+        let strategy = options?.strategy || 'adaptive';
+        if (strategy === 'adaptive') {
+            strategy = getOptimalStrategy(classification.type);
+        }
+        stats.queriesByType[classification.type]++;
+        stats.strategyUsage[strategy]++;
+        // Perform retrieval
+        const limit = options?.limit || 10;
+        let items = [];
+        switch (strategy) {
+            case 'semantic':
+                items = await semanticSearch(query, limit);
+                break;
+            case 'keyword':
+                items = keywordSearch(query, limit);
+                break;
+            case 'graph':
+                items = graphSearch(query, limit);
+                break;
+            case 'hybrid':
+                items = hybridSearch(query, limit);
+                break;
+            default:
+                items = adaptiveSearch(query, limit, classification);
+        }
+        let refinementIterations = 0;
+        // Iterative refinement
+        if (cfg.enableRefinement && items.length > 0) {
+            let results = { items, strategy, queryType: classification.type, refinementIterations, timestamp: Date.now() };
+            while (refinementIterations < cfg.maxRefinementIterations) {
+                const avgScore = results.items.reduce((sum, i) => sum + i.score, 0) / results.items.length;
+                if (avgScore >= cfg.relevanceThreshold)
+                    break;
+                results = refineResults(results, query);
+                refinementIterations++;
+            }
+            items = results.items;
+        }
+        const retrievalTime = Date.now() - startTime;
+        stats.avgRetrievalTime = (stats.avgRetrievalTime * (stats.totalQueries - 1) + retrievalTime) / stats.totalQueries;
+        stats.avgRefinementIterations = (stats.avgRefinementIterations * (stats.totalQueries - 1) + refinementIterations) / stats.totalQueries;
+        const result = {
+            items: items,
+            strategy,
+            queryType: classification.type,
+            refinementIterations,
+            timestamp: Date.now(),
+        };
+        queryCache.set(cacheKey, result);
+        if (queryCache.size > 100) {
+            // Remove oldest entry
+            const firstKey = queryCache.keys().next().value;
+            if (firstKey)
+                queryCache.delete(firstKey);
+        }
+        return result;
+    }
+    async function retrieveByType(query, type) {
+        const classification = classifyQuery(query);
+        return retrieve(query, { strategy: getOptimalStrategy(type) });
+    }
+    function semanticSearch(query, limit) {
+        const queryLower = query.toLowerCase();
+        const queryWords = queryLower.split(/\s+/).filter(w => w.length > 2);
+        const results = [];
+        for (const entry of memoryEntries.values()) {
+            const contentLower = entry.content.toLowerCase();
+            const contentWords = contentLower.split(/\s+/).filter(w => w.length > 2);
+            // TF-IDF like scoring
+            let score = 0;
+            for (const qWord of queryWords) {
+                for (const cWord of contentWords) {
+                    if (cWord.includes(qWord) || qWord.includes(cWord)) {
+                        score += 1 / (1 + Math.abs(cWord.length - qWord.length));
+                    }
+                }
+            }
+            // Boost by success rate and recency
+            score *= (0.5 + entry.successRate * 0.5);
+            const recencyBoost = Math.exp(-(Date.now() - entry.lastAccessed) / (7 * 24 * 60 * 60 * 1000));
+            score *= (1 + recencyBoost * cfg.recencyWeight);
+            if (score > 0) {
+                results.push({ item: entry, score });
+            }
+        }
+        return results
+            .sort((a, b) => b.score - a.score)
+            .slice(0, limit)
+            .map(r => ({
+            content: r.item.content,
+            score: r.score,
+            source: r.item.id,
+            relevance: `semantic_match:${r.score.toFixed(2)}`,
+        }));
+    }
+    function keywordSearch(query, limit) {
+        const queryLower = query.toLowerCase();
+        const queryWords = queryLower.split(/\s+/);
+        const results = [];
+        for (const entry of memoryEntries.values()) {
+            const contentLower = entry.content.toLowerCase();
+            let matchCount = 0;
+            let matchedWords = [];
+            for (const word of queryWords) {
+                if (contentLower.includes(word)) {
+                    matchCount++;
+                    matchedWords.push(word);
+                }
+            }
+            if (matchCount > 0) {
+                const score = matchCount / queryWords.length;
+                results.push({ item: entry, score });
+            }
+        }
+        return results
+            .sort((a, b) => b.score - a.score)
+            .slice(0, limit)
+            .map(r => ({
+            content: r.item.content,
+            score: r.score,
+            source: r.item.id,
+            relevance: `keyword_match:${r.score.toFixed(2)}`,
+        }));
+    }
+    function graphSearch(query, limit) {
+        // Simplified graph-based search
+        // In a real implementation, this would use a knowledge graph
+        const classification = classifyQuery(query);
+        // Search by query type affinity
+        const results = [];
+        for (const entry of memoryEntries.values()) {
+            // Boost entries that match the query type
+            const typeMatch = entry.queryTypes.includes(classification.type) ? 0.3 : 0;
+            const contentMatch = semanticSearch(query, limit).find(r => r.source === entry.id);
+            let score = typeMatch;
+            if (contentMatch) {
+                score += contentMatch.score * 0.7;
+            }
+            if (score > 0) {
+                results.push({ item: entry, score });
+            }
+        }
+        return results
+            .sort((a, b) => b.score - a.score)
+            .slice(0, limit)
+            .map(r => ({
+            content: r.item.content,
+            score: r.score,
+            source: r.item.id,
+            relevance: `graph_match:${r.score.toFixed(2)}`,
+        }));
+    }
+    function hybridSearch(query, limit) {
+        // Combine semantic and keyword search
+        const semanticResults = semanticSearch(query, limit);
+        const keywordResults = keywordSearch(query, limit);
+        // Merge and dedupe
+        const seen = new Set();
+        const merged = [];
+        for (const r of semanticResults) {
+            if (!seen.has(r.source)) {
+                seen.add(r.source);
+                merged.push(r);
+            }
+        }
+        for (const r of keywordResults) {
+            if (!seen.has(r.source)) {
+                seen.add(r.source);
+                merged.push({ ...r, score: r.score * 0.8 }); // Weight keyword results slightly lower
+            }
+        }
+        return merged.sort((a, b) => b.score - a.score).slice(0, limit);
+    }
+    function adaptiveSearch(query, limit, classification) {
+        const strategy = getOptimalStrategy(classification.type);
+        switch (strategy) {
+            case 'semantic':
+                return semanticSearch(query, limit);
+            case 'keyword':
+                return keywordSearch(query, limit);
+            case 'graph':
+                return graphSearch(query, limit);
+            case 'hybrid':
+                return hybridSearch(query, limit);
+            default:
+                return hybridSearch(query, limit);
+        }
+    }
+    function refineResults(results, query) {
+        const queryWords = query.toLowerCase().split(/\s+/).filter(w => w.length > 2);
+        // Re-score based on additional factors
+        const refinedItems = results.items.map(item => {
+            let newScore = item.score;
+            // Boost items with more query word coverage
+            const contentLower = String(item.content).toLowerCase();
+            const coverage = queryWords.filter(w => contentLower.includes(w)).length / queryWords.length;
+            newScore *= (1 + coverage * 0.5);
+            // Boost diverse results (avoid similar content)
+            return { ...item, score: newScore };
+        });
+        // Sort by score
+        refinedItems.sort((a, b) => b.score - a.score);
+        return {
+            ...results,
+            items: refinedItems,
+            refinementIterations: results.refinementIterations + 1,
+        };
+    }
+    function addEntry(entry) {
+        const id = randomUUID();
+        const memoryEntry = {
+            ...entry,
+            id,
+            accessCount: 0,
+            lastAccessed: Date.now(),
+            successRate: 0.5,
+        };
+        memoryEntries.set(id, memoryEntry);
+        return id;
+    }
+    function updateEntry(id, updates) {
+        const entry = memoryEntries.get(id);
+        if (entry) {
+            Object.assign(entry, updates);
+        }
+    }
+    function getEntry(id) {
+        return memoryEntries.get(id);
+    }
+    function learnFromFeedback(query, retrievedIds, helpful) {
+        queryHistory.push({
+            query,
+            type: classifyQuery(query).type,
+            strategy: getOptimalStrategy(classifyQuery(query).type),
+            success: helpful,
+        });
+        // Update success rates
+        for (const id of retrievedIds) {
+            const entry = memoryEntries.get(id);
+            if (entry) {
+                entry.accessCount++;
+                entry.lastAccessed = Date.now();
+                entry.successRate = entry.successRate * 0.95 + (helpful ? 0.05 : 0);
+            }
+        }
+        // Keep history bounded
+        if (queryHistory.length > 100) {
+            queryHistory.shift();
+        }
+    }
+    function getOptimalStrategy(queryType) {
+        const preferences = STRATEGY_PREFERENCES[queryType];
+        // Look at recent history to find best performing strategy
+        const recentByType = queryHistory.filter(q => q.type === queryType).slice(-20);
+        if (recentByType.length < 3) {
+            return preferences[0];
+        }
+        const strategyCounts = new Map();
+        for (const q of recentByType) {
+            const current = strategyCounts.get(q.strategy) || { total: 0, success: 0 };
+            current.total++;
+            if (q.success)
+                current.success++;
+            strategyCounts.set(q.strategy, current);
+        }
+        let bestStrategy = preferences[0];
+        let bestSuccessRate = 0;
+        for (const [strategy, counts] of strategyCounts) {
+            const rate = counts.success / counts.total;
+            if (rate > bestSuccessRate) {
+                bestSuccessRate = rate;
+                bestStrategy = strategy;
+            }
+        }
+        return bestStrategy;
+    }
+    function getConfig() {
+        return { ...cfg };
+    }
+    function updateConfig(newConfig) {
+        Object.assign(cfg, newConfig);
+    }
+    function getStats() {
+        return { ...stats };
+    }
+    return {
+        classifyQuery,
+        retrieve,
+        retrieveByType,
+        addEntry,
+        updateEntry,
+        getEntry,
+        learnFromFeedback,
+        getConfig,
+        updateConfig,
+        getStats,
+        getOptimalStrategy,
+        refineResults,
+    };
+}
+// Helper to format retrieval results
+export function formatRetrievalResult(result) {
+    const itemsStr = result.items.map((i, idx) => `${idx + 1}. [${i.score.toFixed(2)}] ${String(i.content).slice(0, 80)}...`).join('\n');
+    return `
+Retrieval Result:
+  Strategy: ${result.strategy}
+  Query Type: ${result.queryType}
+  Items: ${result.items.length}
+  Refinements: ${result.refinementIterations}
+  Timestamp: ${new Date(result.timestamp).toISOString()}
+
+Items:
+${itemsStr}
+  `.trim();
+}

package/dist/core/memory/archive-store.js

@@ -0,0 +1,187 @@
+import { randomUUID } from 'crypto';
+import { atomicWriteJSON, ensureDir, safeReadDir, readJSON } from '../../storage/archive.js';
+const BLOCKS_DIR = 'blocks';
+const INDEX_FILE = 'index.json';
+async function loadIndex(dataDir) {
+    const indexPath = `${dataDir}/${INDEX_FILE}`;
+    const data = await readJSON(indexPath, { entries: {}, version: 1 });
+    return data;
+}
+async function saveIndex(impl) {
+    if (!impl.indexDirty)
+        return;
+    const indexPath = `${impl.dataDir}/${INDEX_FILE}`;
+    await atomicWriteJSON(indexPath, impl.index);
+    impl.indexDirty = false;
+}
+async function loadEntry(dataDir, id) {
+    const blockPath = `${dataDir}/${BLOCKS_DIR}/${id}.json`;
+    return await readJSON(blockPath, null);
+}
+async function saveEntry(dataDir, entry) {
+    const blockPath = `${dataDir}/${BLOCKS_DIR}/${entry.id}.json`;
+    await atomicWriteJSON(blockPath, entry);
+}
+export function createArchiveStore(dataDir) {
+    const impl = {
+        dataDir,
+        index: { entries: {}, version: 1 },
+        indexDirty: false,
+    };
+    const archive = async (entries) => {
+        await ensureDir(`${dataDir}/${BLOCKS_DIR}`);
+        const ids = [];
+        for (const entry of entries) {
+            const id = entry.id || randomUUID();
+            const finalEntry = { ...entry, id };
+            await saveEntry(dataDir, finalEntry);
+            impl.index.entries[id] = {
+                id,
+                tags: finalEntry.tags,
+                timestamp: finalEntry.timestamp,
+                importance: finalEntry.importance,
+            };
+            impl.indexDirty = true;
+            ids.push(id);
+        }
+        await saveIndex(impl);
+        return ids;
+    };
+    const retrieve = async (id) => {
+        return await loadEntry(dataDir, id);
+    };
+    const search = async (query, limit = 20) => {
+        const results = [];
+        const queryLower = query.toLowerCase();
+        // Simple keyword matching in index first
+        for (const [id, indexEntry] of Object.entries(impl.index.entries)) {
+            const contentMatch = id.includes(queryLower) ||
+                indexEntry.tags.some(t => t.toLowerCase().includes(queryLower));
+            if (contentMatch) {
+                const entry = await loadEntry(dataDir, id);
+                if (entry) {
+                    results.push({
+                        entry,
+                        score: indexEntry.importance,
+                    });
+                }
+            }
+        }
+        // Sort by importance descending
+        results.sort((a, b) => b.score - a.score);
+        return results.slice(0, limit).map(r => r.entry);
+    };
+    const getByTimeRange = async (start, end) => {
+        const results = [];
+        for (const [id, indexEntry] of Object.entries(impl.index.entries)) {
+            if (indexEntry.timestamp >= start && indexEntry.timestamp <= end) {
+                const entry = await loadEntry(dataDir, id);
+                if (entry) {
+                    results.push(entry);
+                }
+            }
+        }
+        // Sort by timestamp descending (newest first)
+        results.sort((a, b) => b.timestamp - a.timestamp);
+        return results;
+    };
+    const getByTag = async (tag) => {
+        const results = [];
+        const tagLower = tag.toLowerCase();
+        for (const [id, indexEntry] of Object.entries(impl.index.entries)) {
+            if (indexEntry.tags.some(t => t.toLowerCase() === tagLower)) {
+                const entry = await loadEntry(dataDir, id);
+                if (entry) {
+                    results.push(entry);
+                }
+            }
+        }
+        // Sort by importance descending
+        results.sort((a, b) => b.importance - a.importance);
+        return results;
+    };
+    const exportArchive = async () => {
+        const allEntries = [];
+        for (const id of Object.keys(impl.index.entries)) {
+            const entry = await loadEntry(dataDir, id);
+            if (entry) {
+                allEntries.push(entry);
+            }
+        }
+        return JSON.stringify({
+            version: 1,
+            exportedAt: Date.now(),
+            entries: allEntries,
+        }, null, 2);
+    };
+    const importArchive = async (json) => {
+        const data = JSON.parse(json);
+        if (!data.entries || !Array.isArray(data.entries)) {
+            throw new Error('Invalid archive format');
+        }
+        let imported = 0;
+        for (const entry of data.entries) {
+            if (entry.id) {
+                await saveEntry(dataDir, entry);
+                impl.index.entries[entry.id] = {
+                    id: entry.id,
+                    tags: entry.tags || [],
+                    timestamp: entry.timestamp || Date.now(),
+                    importance: entry.importance || 0.5,
+                };
+                imported++;
+            }
+        }
+        impl.indexDirty = true;
+        await saveIndex(impl);
+        return imported;
+    };
+    const getStats = async () => {
+        let totalSize = 0;
+        let oldestEntry = null;
+        let newestEntry = null;
+        for (const [id, indexEntry] of Object.entries(impl.index.entries)) {
+            if (!oldestEntry || indexEntry.timestamp < oldestEntry) {
+                oldestEntry = indexEntry.timestamp;
+            }
+            if (!newestEntry || indexEntry.timestamp > newestEntry) {
+                newestEntry = indexEntry.timestamp;
+            }
+            // Estimate size from entry
+            totalSize += JSON.stringify(indexEntry).length;
+        }
+        return {
+            totalEntries: Object.keys(impl.index.entries).length,
+            totalSize,
+            oldestEntry,
+            newestEntry,
+        };
+    };
+    const boot = async () => {
+        await ensureDir(`${dataDir}/${BLOCKS_DIR}`);
+        const loadedIndex = await loadIndex(dataDir);
+        impl.index = loadedIndex;
+        // Verify index consistency - check that all indexed entries exist
+        const blockFiles = await safeReadDir(`${dataDir}/${BLOCKS_DIR}`);
+        const validIds = new Set(blockFiles.map(f => f.replace('.json', '')));
+        for (const id of Object.keys(impl.index.entries)) {
+            if (!validIds.has(id)) {
+                // Entry indexed but block file missing - rebuild index
+                console.warn(`Archive index inconsistency: block file missing for ${id}, rebuilding index...`);
+                impl.index.entries = {};
+                break;
+            }
+        }
+    };
+    return {
+        archive,
+        retrieve,
+        search,
+        getByTimeRange,
+        getByTag,
+        exportArchive,
+        importArchive,
+        getStats,
+        boot,
+    };
+}