mark-improving-agent 2.2.0

package/dist/core/security/privacy.js

@@ -0,0 +1,132 @@
+/**
+ * Privacy & Security - Sensitive Information Protection
+ *
+ * Based on AI Agent Security Paper findings:
+ * - Internal intelligence leakage via CoT
+ * - Memory privacy concerns
+ * - Context compression risks
+ * - Multi-agent communication security
+ */
+const DEFAULT_CONFIG = {
+    enableAutoRedact: true,
+    enableLeakDetection: true,
+    enableSecure记忆: true,
+    blockedPatterns: [
+        'api_key', 'apikey', 'api-key',
+        'secret', 'password', 'pwd',
+        'token', 'auth',
+        'sk-', 'sk_live_',
+        'ghp_', 'github_pat_',
+    ],
+};
+// Common patterns for sensitive information
+const PATTERNS = {
+    api_key: /(?:api[_-]?key|apikey|sk_live_|sk-[a-zA-Z0-9]{20,})[=:\s]*['"]?([a-zA-Z0-9_-]{10,})['"]?/gi,
+    github_token: /ghp_[a-zA-Z0-9]{36}/gi,
+    github_pat: /github_pat_[a-zA-Z0-9_]{82}/gi,
+    openai_key: /sk-[a-zA-Z0-9]{48}/gi,
+    email: /[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}/gi,
+    phone: /1[3-9]\d{9}/gi,
+    password: /(?:password|pwd|passwd)[=:\s]*['"]?([^\s'"]{6,})['"]?/gi,
+    aws_key: /(?:AWS|aws)[_-]?(?:access[_-]?key[_-]?id|secret[_-]?access[_-]?key)[=:]\s*['"]?([A-Za-z0-9/+=]{20,})['"]?/gi,
+    private_key: /-----BEGIN [A-Z]+ PRIVATE KEY-----/gi,
+};
+export function createSecurityChecker(config = {}) {
+    const cfg = { ...DEFAULT_CONFIG, ...config };
+    let scans = 0;
+    let leaksFound = 0;
+    let redactedCount = 0;
+    function scan(text) {
+        scans++;
+        const infos = [];
+        for (const [type, pattern] of Object.entries(PATTERNS)) {
+            const regex = new RegExp(pattern.source, pattern.flags);
+            let match;
+            while ((match = regex.exec(text)) !== null) {
+                const value = match[1] || match[0];
+                const redacted = type + '_REDACTED_' + value.slice(-4);
+                infos.push({
+                    type: type,
+                    value: value,
+                    redacted: redacted,
+                    startIndex: match.index,
+                    endIndex: match.index + match[0].length,
+                });
+                leaksFound++;
+            }
+        }
+        return infos;
+    }
+    function redact(text) {
+        const infos = scan(text);
+        let redacted = text;
+        // Replace from end to avoid index shifting
+        const sortedInfos = [...infos].sort((a, b) => b.startIndex - a.startIndex);
+        for (const info of sortedInfos) {
+            redacted = redacted.slice(0, info.startIndex) + info.redacted + redacted.slice(info.endIndex);
+            redactedCount++;
+        }
+        return { redacted, infos };
+    }
+    function isMemorySecure(content) {
+        const reasons = [];
+        // Check for sensitive patterns
+        const infos = scan(content);
+        if (infos.length > 0) {
+            reasons.push('Contains ' + infos.length + ' sensitive info pattern(s)');
+        }
+        // Check for private keys
+        if (content.includes('-----BEGIN') && content.includes('PRIVATE KEY')) {
+            reasons.push('Contains private key');
+        }
+        // Check for GitHub tokens
+        if (content.includes('ghp_') || content.includes('github_pat_')) {
+            reasons.push('Contains GitHub token');
+        }
+        return {
+            secure: reasons.length === 0,
+            reasons,
+        };
+    }
+    function checkGitHubSafe(content) {
+        const warnings = [];
+        // Check for API keys
+        if (content.includes('api_key') || content.includes('apikey')) {
+            warnings.push('API key detected - do not commit');
+        }
+        // Check for tokens
+        if (content.includes('token') || content.includes('secret')) {
+            warnings.push('Token/secret detected - do not commit');
+        }
+        // Check for private keys
+        if (content.includes('-----BEGIN')) {
+            warnings.push('Private key detected - do not commit');
+        }
+        // Check for personal info
+        if (content.includes('@') && content.includes('.com')) {
+            const emailPattern = /[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}/g;
+            const emails = content.match(emailPattern);
+            if (emails && emails.length > 0) {
+                warnings.push('Email address detected - personal info');
+            }
+        }
+        return {
+            safe: warnings.length === 0,
+            warnings,
+        };
+    }
+    function getSecurityStats() {
+        return {
+            scans,
+            leaksFound,
+            redactedCount,
+        };
+    }
+    return {
+        scan,
+        redact,
+        isMemorySecure,
+        checkGitHubSafe,
+        getSecurityStats,
+    };
+}

package/dist/core/truth-teller.js

@@ -0,0 +1,253 @@
+/**
+ * Truth Teller Engine - 说实话引擎
+ *
+ * 基于 v0.14.0 核心领悟：
+ * - 当不知道，说不知道
+ * - 当用户错了，敢纠正
+ * - 当不确定，说不确定
+ * - 当需要挑战，敢挑战
+ *
+ * 这是核心功能，不是副作用。
+ */
+import { randomUUID } from 'crypto';
+const DEFAULT_CONFIG = {
+    enabled: true,
+    autoCorrect: false,
+    challengeThreshold: 0.7,
+    uncertaintyTolerance: 0.3,
+};
+export function createTruthTeller() {
+    let config = { ...DEFAULT_CONFIG };
+    const truthHistory = [];
+    let stats = {
+        statementsMade: 0,
+        correctionsOffered: 0,
+        uncertaintiesAdmitted: 0,
+        challengesIssued: 0,
+        truthScore: 1.0,
+    };
+    function calculateTruthLevel(content, confidence) {
+        if (confidence >= 0.9)
+            return 'full_truth';
+        if (confidence >= 0.5)
+            return 'partial_truth';
+        if (confidence >= 0.2)
+            return 'unknown';
+        return 'withholding';
+    }
+    function detectUncertainty(content) {
+        const uncertaintyIndicators = [
+            '可能', '也许', '不确定', '大概', '也许',
+            'maybe', 'perhaps', 'probably', 'possibly', 'uncertain',
+            '我不确定', '我不确定是否', '我不确定这个',
+            '这可能', '这也许', '这大概',
+        ];
+        for (const indicator of uncertaintyIndicators) {
+            if (content.toLowerCase().includes(indicator.toLowerCase())) {
+                return `Detected hedge: "${indicator}"`;
+            }
+        }
+        return null;
+    }
+    function detectPotentialError(content, context) {
+        // Check for common error patterns
+        const errorPatterns = [
+            { pattern: /所有|每个|全部|always|every|all/, reason: 'Overgeneralization detected' },
+            { pattern: /一定|肯定|绝对|always|must|certainly/, reason: 'Absolute claim without qualification' },
+            { pattern: /从来|从未|永远不|never|always not/, reason: 'Overly negative generalization' },
+        ];
+        for (const { pattern, reason } of errorPatterns) {
+            if (pattern.test(content)) {
+                return reason;
+            }
+        }
+        return null;
+    }
+    function sayTruth(statement, context = '') {
+        const confidence = estimateConfidence(statement);
+        const uncertainty = detectUncertainty(statement);
+        const truthLevel = calculateTruthLevel(statement, confidence);
+        const truthStatement = {
+            id: randomUUID(),
+            content: statement,
+            truthLevel,
+            confidence,
+            uncertainty,
+            timestamp: Date.now(),
+            context,
+        };
+        truthHistory.push(truthStatement);
+        stats.statementsMade++;
+        if (truthLevel === 'unknown') {
+            stats.uncertaintiesAdmitted++;
+        }
+        updateTruthScore();
+        return truthStatement;
+    }
+    function sayUnknown(question, context = '') {
+        const statement = `我不知道。`;
+        const truthStatement = {
+            id: randomUUID(),
+            content: statement,
+            truthLevel: 'unknown',
+            confidence: 0,
+            uncertainty: `Question exceeds current knowledge: "${question}"`,
+            timestamp: Date.now(),
+            context,
+        };
+        truthHistory.push(truthStatement);
+        stats.statementsMade++;
+        stats.uncertaintiesAdmitted++;
+        updateTruthScore();
+        return truthStatement;
+    }
+    function correctUser(statement, correction, context = '') {
+        const truthStatement = {
+            id: randomUUID(),
+            content: `你刚才说的"${statement.slice(0, 50)}..."可能需要修正。`,
+            truthLevel: 'full_truth',
+            confidence: 0.9,
+            uncertainty: null,
+            correction,
+            timestamp: Date.now(),
+            context,
+        };
+        truthHistory.push(truthStatement);
+        stats.statementsMade++;
+        stats.correctionsOffered++;
+        updateTruthScore();
+        return truthStatement;
+    }
+    function challengeAssumption(assumption, reason) {
+        const truthStatement = {
+            id: randomUUID(),
+            content: `我需要挑战你的假设：${assumption}`,
+            truthLevel: 'full_truth',
+            confidence: 0.85,
+            uncertainty: null,
+            correction: reason,
+            timestamp: Date.now(),
+            context: 'challenge',
+        };
+        truthHistory.push(truthStatement);
+        stats.statementsMade++;
+        stats.challengesIssued++;
+        updateTruthScore();
+        return truthStatement;
+    }
+    function askDifficultQuestion(question) {
+        const difficultQuestions = [
+            `你怎么知道这个是真的？`,
+            `你能证明这个吗？`,
+            `如果这个错了，会怎么样？`,
+            `你有没有考虑过相反的观点？`,
+            `你的假设是什么？`,
+            `你怎么确定的？`,
+        ];
+        // Select based on question content
+        const hash = question.split('').reduce((a, b) => a + b.charCodeAt(0), 0);
+        return difficultQuestions[hash % difficultQuestions.length];
+    }
+    function estimateConfidence(statement) {
+        // Simple heuristic-based confidence estimation
+        let confidence = 0.7;
+        // Certainty words increase confidence
+        const certaintyWords = ['确定', '肯定', '知道', '事实', '数据', '研究', '证明', 'certain', 'know', 'fact', 'data'];
+        for (const word of certaintyWords) {
+            if (statement.toLowerCase().includes(word.toLowerCase())) {
+                confidence += 0.05;
+            }
+        }
+        // Uncertainty words decrease confidence
+        const uncertaintyWords = ['可能', '也许', '不确定', '大概', 'maybe', 'perhaps', 'probably', 'uncertain'];
+        for (const word of uncertaintyWords) {
+            if (statement.toLowerCase().includes(word.toLowerCase())) {
+                confidence -= 0.15;
+            }
+        }
+        // Over-generalization decreases confidence
+        const overGeneralizations = ['所有', '每个', '全部', 'always', 'every', 'all', 'never'];
+        for (const word of overGeneralizations) {
+            if (statement.toLowerCase().includes(word.toLowerCase())) {
+                confidence -= 0.1;
+            }
+        }
+        return Math.max(0, Math.min(1, confidence));
+    }
+    function assessSelfTruth() {
+        const areas = [];
+        if (stats.uncertaintiesAdmitted < 5 && stats.statementsMade > 20) {
+            areas.push('May be over-confident in some areas');
+        }
+        if (stats.correctionsOffered > stats.statementsMade * 0.3) {
+            areas.push('Tends to challenge frequently');
+        }
+        if (stats.correctionsOffered < 3 && stats.statementsMade > 50) {
+            areas.push('May not be correcting enough');
+        }
+        return {
+            truthfulness: stats.truthScore,
+            areas,
+        };
+    }
+    function updateTruthScore() {
+        const total = stats.statementsMade;
+        if (total === 0) {
+            stats.truthScore = 1.0;
+            return;
+        }
+        // Truth score based on ratio of full truths to total statements
+        const fullTruths = truthHistory.filter(s => s.truthLevel === 'full_truth').length;
+        const unknowns = truthHistory.filter(s => s.truthLevel === 'unknown').length;
+        // High unknowns rate is actually good (honest about not knowing)
+        const honestyScore = 1 - (unknowns / Math.max(1, total));
+        const accuracyScore = fullTruths / Math.max(1, total);
+        stats.truthScore = (honestyScore + accuracyScore) / 2;
+    }
+    function getConfig() {
+        return { ...config };
+    }
+    function updateConfig(newConfig) {
+        config = { ...config, ...newConfig };
+    }
+    function getStats() {
+        return { ...stats };
+    }
+    function getTruthHistory(limit = 20) {
+        return truthHistory.slice(-limit);
+    }
+    return {
+        sayTruth,
+        sayUnknown,
+        correctUser,
+        challengeAssumption,
+        askDifficultQuestion,
+        assessSelfTruth,
+        getConfig,
+        updateConfig,
+        getStats,
+        getTruthHistory,
+    };
+}
+// Helper to format truth statements
+export function formatTruthStatement(statement) {
+    let output = '';
+    switch (statement.truthLevel) {
+        case 'full_truth':
+            output = statement.content;
+            break;
+        case 'partial_truth':
+            output = `${statement.content}${statement.uncertainty ? ` (${statement.uncertainty})` : ''}`;
+            break;
+        case 'unknown':
+            output = `${statement.content}${statement.uncertainty ? ` ${statement.uncertainty}` : ''}`;
+            break;
+        case 'withholding':
+            output = '[Information withheld due to uncertainty]';
+            break;
+    }
+    if (statement.correction) {
+        output += `\nCorrection: ${statement.correction}`;
+    }
+    return output;
+}

package/dist/core/truthfulness.js

@@ -0,0 +1,99 @@
+/**
+ * Truthfulness System - Avoid lying, no hedging, evidence-based conclusions
+ *
+ * From learnings: "结论必须有证据，没证据就承认不知道，绝不编数字"
+ */
+import { ensureDir, atomicWriteJSON, readJSON } from '../storage/archive.js';
+const ABSOLUTE_WORDS = ['肯定', '绝对', '一定', '必然', '毫无疑问', '绝对确定'];
+const NUMBER_PATTERN = /\d+/g;
+export function createTruthfulnessChecker(dataDir) {
+    let stats = {
+        totalStatements: 0,
+        liesCaught: 0,
+    };
+    const filePath = `${dataDir}/truthfulness-stats.json`;
+    let dirty = false;
+    async function persist() {
+        if (!dirty)
+            return;
+        await atomicWriteJSON(filePath, stats);
+        dirty = false;
+    }
+    async function boot() {
+        await ensureDir(dataDir);
+        try {
+            const loaded = await readJSON(filePath, { totalStatements: 0, liesCaught: 0 });
+            if (loaded && typeof loaded.totalStatements === 'number') {
+                stats = loaded;
+            }
+        }
+        catch {
+            // File doesn't exist or corrupt, use defaults
+        }
+    }
+    function checkStatement(statement) {
+        stats.totalStatements++;
+        dirty = true;
+        let isLying = false;
+        let reason = '';
+        // Check for absolute words without evidence indicators
+        const hasAbsoluteWords = ABSOLUTE_WORDS.some(word => statement.includes(word));
+        const hasEvidence = statement.includes('因为') || statement.includes('证据') ||
+            statement.includes('根据') || statement.includes('数据显示') ||
+            statement.includes('研究显示') || statement.includes('数据表明');
+        if (hasAbsoluteWords && !hasEvidence) {
+            isLying = true;
+            reason = 'Contains absolute words without supporting evidence';
+            stats.liesCaught++;
+            dirty = true;
+        }
+        // Check for numbers without sources
+        const numbers = statement.match(NUMBER_PATTERN);
+        if (numbers) {
+            const hasSource = statement.includes('根据') || statement.includes('来自') ||
+                statement.includes('数据显示') || statement.includes('统计') ||
+                statement.includes('研究') || statement.includes('报告');
+            if (!hasSource && numbers.length > 0) {
+                // Flag if there are specific numbers that seem invented
+                const specificNumbers = numbers.filter(n => n.length >= 2); // Ignore single digits
+                if (specificNumbers.length > 0 && !hasEvidence) {
+                    isLying = true;
+                    reason = reason || 'Contains specific numbers without cited source';
+                    stats.liesCaught++;
+                    dirty = true;
+                }
+            }
+        }
+        const confidence = isLying ? 0.3 : 0.9;
+        return { isLying, confidence, reason: reason || 'Statement appears credible' };
+    }
+    function annotateConfidence(statement, confidence) {
+        if (confidence < 0.8) {
+            const percent = Math.round(confidence * 100);
+            return `${statement} (置信度: ${percent}%)`;
+        }
+        return statement;
+    }
+    function recordLie(statement, context) {
+        stats.liesCaught++;
+        stats.totalStatements++;
+        dirty = true;
+        // In a full implementation, this would also log the lie details
+    }
+    function getLyingStats() {
+        const lieRate = stats.totalStatements > 0 ? stats.liesCaught / stats.totalStatements : 0;
+        return {
+            totalStatements: stats.totalStatements,
+            liesCaught: stats.liesCaught,
+            lieRate,
+        };
+    }
+    // Boot immediately in constructor
+    boot().catch(() => { });
+    return {
+        checkStatement,
+        annotateConfidence,
+        recordLie,
+        getLyingStats,
+    };
+}

package/dist/core/types.js

@@ -0,0 +1,2 @@
+// Re-export all types from submodules
+export {};

package/dist/event/bus.js

@@ -0,0 +1,47 @@
+export class EventBus {
+    handlers = new Map();
+    emit(event, data) {
+        const eventHandlers = this.handlers.get(event);
+        if (eventHandlers) {
+            for (const handler of eventHandlers) {
+                try {
+                    handler(data);
+                }
+                catch (err) {
+                    console.error(`Error in event handler for ${event}:`, err);
+                }
+            }
+        }
+    }
+    on(event, handler) {
+        let eventHandlers = this.handlers.get(event);
+        if (!eventHandlers) {
+            eventHandlers = new Set();
+            this.handlers.set(event, eventHandlers);
+        }
+        eventHandlers.add(handler);
+        return () => {
+            this.off(event, handler);
+        };
+    }
+    once(event, handler) {
+        const wrapped = (data) => {
+            handler(data);
+            this.off(event, wrapped);
+        };
+        return this.on(event, wrapped);
+    }
+    off(event, handler) {
+        const eventHandlers = this.handlers.get(event);
+        if (eventHandlers) {
+            eventHandlers.delete(handler);
+            if (eventHandlers.size === 0) {
+                this.handlers.delete(event);
+            }
+        }
+    }
+    removeAllListeners() {
+        this.handlers.clear();
+    }
+}
+export const events = new EventBus();

package/dist/index.js

@@ -0,0 +1,8 @@
+// Main export for HeartFlow framework
+export { createHeartFlow } from './core/heartbeat.js';
+export { VERSION } from './version.js';
+export * from './core/psychology/index.js';
+export * from './core/cognition/index.js';
+export { createAdaptiveRAGMemory, formatRetrievalResult } from './core/memory/adaptive-rag.js';
+export { createTruthTeller, formatTruthStatement } from './core/truth-teller.js';
+export { createActiveInferenceEngine, formatFreeEnergyMetrics, formatBeliefState } from './core/cognition/active-inference.js';