mark-improving-agent 2.3.0 → 2.3.1

package/VERSION

@@ -1 +1 @@
-2.3.0
+2.3.1

package/dist/core/behavior-playbook.js

@@ -0,0 +1,211 @@
+/**
+ * Behavior Playbook - Pattern-Based Playbook Extraction System
+ *
+ * Inspired by ReflexioAI's self-improvement framework:
+ * - Extracts actionable playbooks from user correction patterns
+ * - Clusters similar behaviors and aggregates into reusable playbooks
+ * - Tracks playbook effectiveness through success/failure metrics
+ * - Enables cross-session learning (what one user teaches, all sessions benefit)
+ *
+ * @module core/behavior-playbook
+ * @fileoverview Playbook extraction from interaction patterns
+ */
+import { createLogger } from '../utils/logger.js';
+import { atomicWriteJSON, readJSON, ensureDir } from '../storage/archive.js';
+import { randomUUID } from 'crypto';
+const logger = createLogger('[BehaviorPlaybook]');
+const DEFAULT_CONFIG = {
+    minConfidence: 0.6,
+    maxPlaybooks: 100,
+    clusterThreshold: 0.8,
+    autoExtract: true,
+};
+const PLAYBOOKS_FILE = 'behavior-playbooks.json';
+const CORRECTIONS_FILE = 'correction-events.json';
+function extractContext(text) {
+    if (text.length <= 50)
+        return text;
+    return text.slice(0, 47) + '...';
+}
+function extractPlaybookFromCorrection(event) {
+    const { userMessage, correction } = event;
+    if (correction.length < 5 || userMessage.length < 5)
+        return null;
+    let trigger = '';
+    let action = '';
+    const tags = [];
+    const lowerCorrection = correction.toLowerCase();
+    if (lowerCorrection.startsWith("don't") || lowerCorrection.startsWith("do not") || lowerCorrection.startsWith("never")) {
+        const match = correction.match(/(?:don't|do not|never)\s+(.+)/i);
+        if (match) {
+            const avoided = match[1].trim();
+            trigger = `When about to: ${avoided}`;
+            action = `Avoid: ${avoided}`;
+            tags.push('avoid', 'user-warning');
+        }
+    }
+    else if (lowerCorrection.startsWith("you should") || lowerCorrection.startsWith("you need to") || lowerCorrection.startsWith("always")) {
+        const match = correction.match(/(?:you should|you need to|always)\s+(.+)/i);
+        if (match) {
+            const required = match[1].trim();
+            trigger = `When encountering relevant situation`;
+            action = `Always: ${required}`;
+            tags.push('positive', 'user-guidance');
+        }
+    }
+    else {
+        // Generic extraction
+        trigger = extractContext(userMessage);
+        action = correction;
+        tags.push('general', 'user-correction');
+    }
+    if (!trigger || !action)
+        return null;
+    return { trigger, action, tags, source: 'user-correction' };
+}
+function cosineSimilarity(a, b) {
+    const wordsA = new Set(a.toLowerCase().split(/\s+/));
+    const wordsB = new Set(b.toLowerCase().split(/\s+/));
+    const intersection = new Set([...wordsA].filter(x => wordsB.has(x)));
+    const union = new Set([...wordsA, ...wordsB]);
+    if (union.size === 0)
+        return 0;
+    return intersection.size / union.size;
+}
+export function createBehaviorPlaybook(dataDir, config = {}) {
+    const cfg = { ...DEFAULT_CONFIG, ...config };
+    const playbooks = [];
+    const corrections = [];
+    let dirty = false;
+    async function persist() {
+        if (!dirty)
+            return;
+        await Promise.all([
+            atomicWriteJSON(`${dataDir}/${PLAYBOOKS_FILE}`, playbooks),
+            atomicWriteJSON(`${dataDir}/${CORRECTIONS_FILE}`, corrections),
+        ]);
+        dirty = false;
+    }
+    async function boot() {
+        await ensureDir(dataDir);
+        const [loadedPlaybooks, loadedCorrections] = await Promise.all([
+            readJSON(`${dataDir}/${PLAYBOOKS_FILE}`, []),
+            readJSON(`${dataDir}/${CORRECTIONS_FILE}`, []),
+        ]);
+        if (loadedPlaybooks?.length)
+            playbooks.push(...loadedPlaybooks);
+        if (loadedCorrections?.length)
+            corrections.push(...loadedCorrections);
+        logger.info(`Booted with ${playbooks.length} playbooks, ${corrections.length} corrections`);
+    }
+    function addCorrection(event) {
+        const full = { ...event, id: randomUUID(), timestamp: Date.now() };
+        corrections.push(full);
+        if (corrections.length > 500)
+            corrections.splice(0, corrections.length - 500);
+        if (cfg.autoExtract)
+            extractPlaybook(full);
+        return full;
+    }
+    function extractPlaybook(event) {
+        const partial = extractPlaybookFromCorrection(event);
+        if (!partial)
+            return null;
+        // Check for similar existing playbook
+        for (const existing of playbooks) {
+            if (cosineSimilarity(existing.action, partial.action) > cfg.clusterThreshold) {
+                // Update existing playbook's confidence
+                existing.successCount++;
+                existing.confidence = Math.min(0.95, existing.confidence + 0.05);
+                existing.lastUsed = Date.now();
+                dirty = true;
+                return existing;
+            }
+        }
+        const playbook = {
+            id: randomUUID(),
+            trigger: partial.trigger,
+            action: partial.action,
+            confidence: 0.5,
+            successCount: 0,
+            failureCount: 0,
+            source: partial.source,
+            createdAt: Date.now(),
+            lastUsed: Date.now(),
+            tags: partial.tags,
+            version: 1,
+        };
+        playbooks.push(playbook);
+        if (playbooks.length > cfg.maxPlaybooks) {
+            playbooks.splice(0, playbooks.length - cfg.maxPlaybooks);
+        }
+        dirty = true;
+        logger.info(`Extracted playbook: ${playbook.action.slice(0, 50)}`);
+        return playbook;
+    }
+    function getPlaybook(id) {
+        return playbooks.find(p => p.id === id) ?? null;
+    }
+    function searchPlaybooks(query, limit = 5) {
+        const results = [];
+        for (const p of playbooks) {
+            if (p.confidence < cfg.minConfidence)
+                continue;
+            const queryLower = query.toLowerCase();
+            const triggerMatch = p.trigger.toLowerCase().includes(queryLower);
+            const actionMatch = p.action.toLowerCase().includes(queryLower);
+            const tagMatch = p.tags.some(t => t.toLowerCase().includes(queryLower));
+            if (!triggerMatch && !actionMatch && !tagMatch)
+                continue;
+            let score = 0;
+            let matchType = 'fuzzy';
+            if (actionMatch) {
+                score += 0.6;
+                matchType = 'exact';
+            }
+            if (triggerMatch)
+                score += 0.3;
+            if (tagMatch) {
+                score += 0.2;
+                if (matchType !== 'exact')
+                    matchType = 'tag';
+            }
+            score *= p.confidence;
+            results.push({ playbook: p, relevanceScore: score, matchType });
+        }
+        return results.sort((a, b) => b.relevanceScore - a.relevanceScore).slice(0, limit);
+    }
+    function getPlaybooksByTag(tag) {
+        return playbooks.filter(p => p.tags.some(t => t.toLowerCase().includes(tag.toLowerCase())));
+    }
+    function markPlaybookHit(id, success) {
+        const p = playbooks.find(p => p.id === id);
+        if (!p)
+            return;
+        if (success) {
+            p.successCount++;
+            p.confidence = Math.min(0.95, p.confidence + (0.95 - p.confidence) * 0.1);
+        }
+        else {
+            p.failureCount++;
+            p.confidence = Math.max(0.3, p.confidence - 0.05);
+        }
+        p.lastUsed = Date.now();
+        dirty = true;
+    }
+    function getActivePlaybooks() {
+        return playbooks.filter(p => p.confidence >= cfg.minConfidence);
+    }
+    function getStats() {
+        const avgConfidence = playbooks.length ? playbooks.reduce((s, p) => s + p.confidence, 0) / playbooks.length : 0;
+        const tagCounts = new Map();
+        for (const p of playbooks) {
+            for (const t of p.tags) {
+                tagCounts.set(t, (tagCounts.get(t) ?? 0) + 1);
+            }
+        }
+        const topTags = [...tagCounts.entries()].sort((a, b) => b[1] - a[1]).slice(0, 5).map(([t]) => t);
+        return { totalPlaybooks: playbooks.length, avgConfidence, topTags };
+    }
+    return { addCorrection, extractPlaybook, getPlaybook, searchPlaybooks, getPlaybooksByTag, markPlaybookHit, getActivePlaybooks, getStats, boot, persist };
+}

package/dist/index.js

@@ -10,3 +10,4 @@ export { createMCPProtocol } from './core/collaboration/mcp-protocol.js';
 export { createTruthTeller, formatTruthStatement } from './core/truth-teller.js';
 export { createActiveInferenceEngine, formatFreeEnergyMetrics, formatBeliefState } from './core/cognition/active-inference.js';
 export { createExpertModelsEngine } from './core/expert-models/index.js';
+export { createBehaviorPlaybook } from './core/behavior-playbook.js';

package/dist/version.js

@@ -1 +1 @@
-export const VERSION = '2.3.0';
+export const VERSION = '2.3.1';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mark-improving-agent",
-  "version": "2.3.0",
+  "version": "2.3.1",
   "description": "Self-evolving AI agent with permanent memory, identity continuity, and self-evolution — for AI agents that need to remember, learn, and evolve across sessions",
   "type": "module",
   "main": "./dist/index.js",