mindforge-memory 6.4.1__py3-none-any.whl

mindforge/modules/personality.py

@@ -0,0 +1,275 @@
+"""
+MindForge v5.0 人格化引擎
+学习用户偏好、语言风格、思维模式
+"""
+
+import json
+import logging
+import time
+import re
+import sqlite3  # v5.4.7 修复 C-4：异常处理中引用 sqlite3.OperationalError 需要此导入
+from dataclasses import dataclass, field
+from typing import Dict, List, Optional, Any, Tuple
+
+from mindforge.core.storage import StorageEngine
+
+# v6.1.2 修复：与上面 C-4 同源——第 81 / 270 行的画像加载与持久化降级分支引用
+# `logger.warning`，但模块从未定义 logger，降级路径本身抛 NameError。
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class UserProfile:
+    """用户画像"""
+    user_id: str = "default"
+    preferences: Dict[str, float] = field(default_factory=dict)
+    language_style: Dict[str, Any] = field(default_factory=dict)
+    topics_of_interest: Dict[str, float] = field(default_factory=dict)
+    technical_level: Dict[str, float] = field(default_factory=dict)
+    communication_patterns: Dict[str, Any] = field(default_factory=dict)
+    learning_style: Dict[str, float] = field(default_factory=dict)
+    interaction_history: List[Dict] = field(default_factory=list)
+    last_updated: float = 0.0
+    total_interactions: int = 0
+
+    def to_dict(self) -> dict:
+        return {
+            "user_id": self.user_id,
+            "preferences": self.preferences,
+            "language_style": self.language_style,
+            "topics_of_interest": self.topics_of_interest,
+            "technical_level": self.technical_level,
+            "communication_patterns": self.communication_patterns,
+            "learning_style": self.learning_style,
+            "total_interactions": self.total_interactions,
+            "last_updated": self.last_updated,
+        }
+
+    @classmethod
+    def from_dict(cls, data: dict) -> "UserProfile":
+        return cls(
+            user_id=data.get("user_id", "default"),
+            preferences=data.get("preferences", {}),
+            language_style=data.get("language_style", {}),
+            topics_of_interest=data.get("topics_of_interest", {}),
+            technical_level=data.get("technical_level", {}),
+            communication_patterns=data.get("communication_patterns", {}),
+            learning_style=data.get("learning_style", {}),
+            total_interactions=data.get("total_interactions", 0),
+            last_updated=data.get("last_updated", 0),
+        )
+
+
+class PersonalityEngine:
+    """人格化引擎"""
+
+    def __init__(self, storage: StorageEngine):
+        self.storage = storage
+        self.profiles: Dict[str, UserProfile] = {}
+        self._load_profiles()
+
+    def _load_profiles(self):
+        """加载用户画像"""
+        try:
+            all_memories = self.storage.list_memories(category="user_profile", limit=100)
+            for entry in all_memories:
+                try:
+                    # P3 #29 修复：使用安全 JSON 解析，防深度嵌套栈溢出
+                    data = self.storage._safe_json_loads(entry.content)
+                    if data is None:
+                        continue
+                    profile = UserProfile.from_dict(data)
+                    self.profiles[profile.user_id] = profile
+                except (json.JSONDecodeError, TypeError, ValueError):
+                    pass
+        except sqlite3.OperationalError as _prof_err:
+            logger.warning("加载用户画像失败，画像检索可能降级: %s", _prof_err)
+
+    def get_profile(self, user_id: str = "default") -> UserProfile:
+        """获取用户画像"""
+        if user_id not in self.profiles:
+            self.profiles[user_id] = UserProfile(user_id=user_id)
+        return self.profiles[user_id]
+
+    def learn_from_interaction(self, user_id: str,
+                               user_message: str,
+                               agent_response: str,
+                               metadata: Optional[Dict] = None):
+        """从交互中学习"""
+        profile = self.get_profile(user_id)
+        profile.total_interactions += 1
+        profile.last_updated = time.time()
+
+        self._analyze_language_style(profile, user_message)
+        self._analyze_topics(profile, user_message)
+        self._analyze_technical_level(profile, user_message)
+        self._analyze_communication_patterns(profile, user_message)
+
+        profile.interaction_history.append({
+            "timestamp": time.time(),
+            "message_length": len(user_message),
+            "response_length": len(agent_response),
+            "metadata": metadata or {},
+        })
+
+        if len(profile.interaction_history) > 1000:
+            profile.interaction_history = profile.interaction_history[-1000:]
+
+        self._save_profile(profile)
+
+    def _analyze_language_style(self, profile: UserProfile, text: str):
+        """分析语言风格"""
+        style = profile.language_style
+
+        style["avg_message_length"] = (
+            style.get("avg_message_length", 0) * 0.9 + len(text) * 0.1
+        )
+
+        formality_score = self._calculate_formality(text)
+        style["formality"] = (
+            style.get("formality", 0.5) * 0.95 + formality_score * 0.05
+        )
+
+        emoji_count = sum(1 for ch in text if ord(ch) > 0x1F000)
+        style["emoji_usage"] = (
+            style.get("emoji_usage", 0) * 0.9 + min(emoji_count / 5, 1.0) * 0.1
+        )
+
+        exclamation_count = text.count('!')
+        style["excitement"] = (
+            style.get("excitement", 0.5) * 0.95 + min(exclamation_count / 3, 1.0) * 0.05
+        )
+
+        question_count = text.count('?')
+        style["curiosity"] = (
+            style.get("curiosity", 0.5) * 0.95 + min(question_count / 2, 1.0) * 0.05
+        )
+
+    def _calculate_formality(self, text: str) -> float:
+        """计算正式程度"""
+        formal_words = ['请', '您', '谢谢', '感谢', '请问', '您好', '尊敬', '此致', '敬礼']
+        casual_words = ['哈哈', '哈哈哈哈', 'emmm', 'emm', '啊这', 'yyds', '绝了', '哇']
+
+        formal_score = sum(1 for w in formal_words if w in text)
+        casual_score = sum(1 for w in casual_words if w in text)
+
+        total = formal_score + casual_score + 1
+        return 0.3 + 0.4 * (formal_score / total)
+
+    def _analyze_topics(self, profile: UserProfile, text: str):
+        """分析兴趣主题"""
+        topics = profile.topics_of_interest
+        text_lower = text.lower()
+
+        topic_keywords = {
+            "编程开发": ['代码', '编程', '开发', '函数', '类', '接口', 'api', 'bug', 'debug'],
+            "人工智能": ['ai', '人工智能', '大模型', 'llm', 'gpt', 'agent', '机器学习', '深度学习'],
+            "数据库": ['数据库', 'sql', 'mysql', 'postgresql', 'redis', 'mongodb', '索引', '查询'],
+            "前端开发": ['前端', 'html', 'css', 'javascript', 'react', 'vue', '组件', 'ui'],
+            "生活日常": ['吃饭', '睡觉', '周末', '假期', '旅游', '电影', '音乐', '游戏'],
+            "学习成长": ['学习', '研究', '阅读', '书籍', '课程', '教程', '成长', '进步'],
+        }
+
+        for topic, keywords in topic_keywords.items():
+            count = sum(1 for kw in keywords if kw in text_lower)
+            if count > 0:
+                current = topics.get(topic, 0)
+                topics[topic] = current + count * 0.1
+                if topics[topic] > 1.0:
+                    topics[topic] = 1.0
+
+    def _analyze_technical_level(self, profile: UserProfile, text: str):
+        """分析技术水平"""
+        tech_level = profile.technical_level
+        text_lower = text.lower()
+
+        beginner_words = ['怎么用', '如何', '入门', '新手', '基础', '教程', '简单']
+        advanced_words = ['优化', '架构', '性能', '并发', '分布式', '微服务', '底层', '原理']
+
+        beginner_count = sum(1 for w in beginner_words if w in text_lower)
+        advanced_count = sum(1 for w in advanced_words if w in text_lower)
+
+        current = tech_level.get("overall", 0.5)
+        if advanced_count > beginner_count:
+            new_level = min(1.0, current + 0.02)
+        elif beginner_count > advanced_count:
+            new_level = max(0.0, current - 0.01)
+        else:
+            new_level = current
+
+        tech_level["overall"] = new_level
+
+    def _analyze_communication_patterns(self, profile: UserProfile, text: str):
+        """分析沟通模式"""
+        patterns = profile.communication_patterns
+
+        sentence_count = len(re.split(r'[。！？.!?]', text))
+        patterns["avg_sentences_per_message"] = (
+            patterns.get("avg_sentences_per_message", 3) * 0.9 + sentence_count * 0.1
+        )
+
+        detail_length = len(text) / max(sentence_count, 1)
+        patterns["detail_oriented"] = (
+            patterns.get("detail_oriented", 0.5) * 0.95
+            + min(detail_length / 100, 1.0) * 0.05
+        )
+
+    def get_recommended_style(self, user_id: str = "default") -> Dict:
+        """获取推荐的交流风格"""
+        profile = self.get_profile(user_id)
+        style = profile.language_style
+
+        formality = style.get("formality", 0.5)
+        emoji_usage = style.get("emoji_usage", 0)
+        detail = style.get("detail_oriented", 0.5)
+
+        return {
+            "formality_level": "正式" if formality > 0.7 else "中性" if formality > 0.4 else "轻松",
+            "use_emoji": emoji_usage > 0.3,
+            "detail_level": "详细" if detail > 0.7 else "适中" if detail > 0.4 else "简洁",
+            "response_length": "详细" if detail > 0.6 else "标准",
+            "technical_depth": profile.technical_level.get("overall", 0.5),
+        }
+
+    def get_top_interests(self, user_id: str = "default", top_n: int = 5) -> List[Tuple[str, float]]:
+        """获取最感兴趣的主题"""
+        profile = self.get_profile(user_id)
+        interests = sorted(profile.topics_of_interest.items(), key=lambda x: x[1], reverse=True)
+        return interests[:top_n]
+
+    def _save_profile(self, profile: UserProfile):
+        """保存用户画像"""
+        try:
+            existing = self.storage.list_memories(
+                category="user_profile", limit=10
+            )
+
+            profile_entry = None
+            for entry in existing:
+                try:
+                    # P3 #29 修复：使用安全 JSON 解析
+                    data = self.storage._safe_json_loads(entry.content)
+                    if data is None:
+                        continue
+                    if data.get("user_id") == profile.user_id:
+                        profile_entry = entry
+                        break
+                except (json.JSONDecodeError, TypeError, ValueError):
+                    pass
+
+            content = json.dumps(profile.to_dict(), ensure_ascii=False)
+
+            if profile_entry:
+                self.storage.update_memory(
+                    entry_id=profile_entry.id,
+                    content=content,
+                )
+            else:
+                self.storage.add_memory(
+                    content=content,
+                    category="user_profile",
+                    tags=["profile", profile.user_id],
+                    source_agent="personality_engine",
+                )
+        except (sqlite3.OperationalError, ValueError) as _prof_err:
+            logger.warning("持久化用户画像失败: %s", _prof_err)

mindforge/modules/principled_forgetting.py

@@ -0,0 +1,258 @@
+"""
+MindForge v6.0.0 功能 7：有原则的遗忘（可解释）
+
+不是删数据，而是像人一样：噪音自然淡出、重要模式留下来，
+并且能解释"为什么忘了这段"。
+
+- explain_forgetting(): 对单条记忆给出可解释的遗忘评分分解
+  （时效衰减 / 访问频率 / 重要度保护 / 结果标记 / 噪音判定）
+- run_principled_gc(): 执行有原则的遗忘 GC（复用 MemoryDecayEngine），
+  输出每条被归档记忆的遗忘原因（explainable）
+- forgetting_stats(): 遗忘引擎统计
+
+设计：
+- 复用 mindforge.modules.memory_decay.DecayConfig / MemoryDecayEngine
+- 每条遗忘决策附带 reason 列表（人类可读）
+"""
+
+from __future__ import annotations
+
+import time
+from typing import Any, Dict, List, Optional
+
+_HALF_LIFE_DAYS = 30.0
+
+
+def _decay_score(storage, entry, now: float) -> Dict[str, Any]:
+    """计算单条记忆的遗忘评分分解"""
+    try:
+        from mindforge.modules.memory_decay import MemoryDecayEngine
+        engine = MemoryDecayEngine(storage)
+    except Exception:
+        engine = None
+
+    reasons = []
+    factors = {}
+
+    # 1. 时效衰减（最后访问距今）
+    last_accessed = float(getattr(entry, "last_accessed_at", 0) or 0)
+    created = float(getattr(entry, "created_at", 0) or 0)
+    updated = float(getattr(entry, "updated_at", 0) or 0)
+    ref_ts = max(last_accessed, updated, created) or now
+    age_days = max(0.0, (now - ref_ts) / 86400.0)
+    recency = 1.0 / (1.0 + age_days / _HALF_LIFE_DAYS)
+    factors["recency"] = round(recency, 4)
+    if age_days > _HALF_LIFE_DAYS * 2:
+        reasons.append(f"超过 {int(age_days)} 天未被访问/更新，时效衰减")
+
+    # 2. 访问频率
+    access_count = int(getattr(entry, "access_count", 0) or 0)
+    frequency = min(1.0, access_count / 10.0)
+    factors["frequency"] = round(frequency, 4)
+    if access_count == 0 and age_days > 7:
+        reasons.append("从未被检索/访问，缺乏使用证据")
+
+    # 3. 重要度保护
+    importance_val = getattr(entry, "importance", "") or "MEDIUM"
+    importance = getattr(importance_val, "value", importance_val)
+    importance = str(importance or "MEDIUM").upper()
+    importance_protect = {"HIGH": 0.9, "MEDIUM": 0.5, "LOW": 0.2}.get(importance, 0.5)
+    factors["importance_protection"] = importance_protect
+    if importance == "HIGH":
+        reasons.append("重要度 HIGH：受保护，不易遗忘")
+    elif importance == "LOW":
+        reasons.append("重要度 LOW：弱保护，更容易淡出")
+
+    # 4. 结果标记（功能 5 联动）：success 记忆保留、failure 记忆允许淡出
+    outcome = ""
+    try:
+        conn = storage._get_conn()
+        row = conn.execute(
+            "SELECT outcome FROM memories WHERE id = ?",
+            (getattr(entry, "id", ""),)).fetchone()
+        outcome = row[0] if row else ""
+    except Exception:
+        pass
+    outcome_boost = {"success": 0.3, "partial": 0.1, "failure": -0.2}.get(outcome, 0.0)
+    factors["outcome_boost"] = outcome_boost
+    if outcome == "success":
+        reasons.append("结果标记 success：优先保留")
+    elif outcome == "failure":
+        reasons.append("结果标记 failure：允许降权淡出")
+
+    # 5. 噪声判定（短且无实义）
+    content = (getattr(entry, "content", "") or "").strip()
+    # v6.1.2：原元组里 "住在" 写了两次（笔误，去重后判定结果不变）
+    is_noisy = len(content) < 12 and not any(
+        k in content for k in ("工作", "喜欢", "住在", "是", "目标"))
+    factors["noise"] = 1.0 if is_noisy else 0.0
+    if is_noisy:
+        reasons.append("内容过短且无明确信息量（噪声型记忆）")
+
+    # 综合遗忘倾向（0~1，越高越该遗忘）
+    forget_tendency = round(
+        (1.0 - recency) * 0.45
+        + (1.0 - frequency) * 0.25
+        + (1.0 - importance_protect) * 0.2
+        + (1.0 - (0.5 + outcome_boost)) * 0.1, 4)
+    factors["forget_tendency"] = forget_tendency
+    factors["age_days"] = round(age_days, 2)
+    factors["access_count"] = access_count
+
+    if engine is not None:
+        try:
+            strength = engine.compute_strength(entry)
+            factors["engine_strength"] = round(float(strength or 0.0), 4)
+        except Exception:
+            pass
+    return {"factors": factors, "reasons": reasons,
+            "forget_tendency": forget_tendency}
+
+
+def _coerce_memory_id(memory_id: Any) -> tuple:
+    """接受 str 或 add() 返回的 MemoryEntry，返回 (id, error)。
+
+    v6.0.0 直接 len(memory_id)，传对象会抛 TypeError 而非友好报错（v6.1.1 修）。
+    """
+    if memory_id is None:
+        return None, "记忆 ID 无效"
+    if not isinstance(memory_id, str):
+        memory_id = getattr(memory_id, "id", None)
+        if not isinstance(memory_id, str):
+            return None, "记忆 ID 必须是字符串或 add() 返回的 MemoryEntry 对象"
+    if not memory_id or len(memory_id) > 128:
+        return None, "记忆 ID 无效"
+    return memory_id, None
+
+
+def explain_forgetting(storage, memory_id: str,
+                       actor: str = "", session_id: str = "") -> Dict[str, Any]:
+    """解释一条记忆的遗忘决策"""
+    memory_id, id_error = _coerce_memory_id(memory_id)
+    if id_error:
+        return {"success": False, "error": id_error}
+    entry = storage.get_memory(memory_id, actor, session_id)
+    if entry is None:
+        return {"success": False, "error": "记忆不存在"}
+    now = time.time()
+    d = _decay_score(storage, entry, now)
+    return {
+        "success": True,
+        "memory_id": memory_id,
+        "content_preview": (getattr(entry, "content", "") or "")[:120],
+        "explanation": d["reasons"],
+        "forget_tendency": d["forget_tendency"],
+        "factors": d["factors"],
+        "privacy": "aggregate-only",
+    }
+
+
+def run_principled_gc(mf, dry_run: bool = False, days: int = 30) -> Dict[str, Any]:
+    """执行有原则的遗忘 GC：噪音淡出、重要模式保留，输出可解释决策。
+
+    - 遍历未归档记忆，计算 forget_tendency
+    - 阈值以上且非保护记忆 → 归档（archive），并记录原因
+
+    v6.1.2 修复：`days` 参数自 v6.0.0 起就在签名与门面里一路传进来，函数体却
+    从未引用它（阈值 0.72 硬编码，年龄窗口全靠 forget_tendency 隐式体现），
+    调用者以为在调「GC 年龄窗口」，实际改了个寂寞。现在 `days` 是真正的**冷却
+    窗口**：创建不足 `days` 天的记忆不参与归档，并单独计入 `skipped_too_fresh`；
+    `days <= 0` 表示关闭冷却（用于清理刚写入的成批噪音）。
+    """
+    try:
+        from mindforge.modules.memory_decay import MemoryDecayEngine
+        engine = MemoryDecayEngine(mf._storage)
+    except Exception:
+        engine = None
+
+    try:
+        min_age_days = int(days)
+    except (TypeError, ValueError):
+        min_age_days = 30
+    min_age_seconds = max(0, min_age_days) * 86400.0
+
+    now = time.time()
+    entries = mf._storage.list_memories(limit=10000) or []
+    threshold = 0.72
+    archived = []
+    protected = 0
+    scanned = 0
+    too_fresh = 0
+
+    for entry in entries:
+        imp_val = getattr(entry, "importance", "") or "MEDIUM"
+        importance = str(getattr(imp_val, "value", imp_val) or "MEDIUM").upper()
+        if importance == "HIGH":
+            protected += 1
+            continue
+        if min_age_seconds > 0:
+            created_at = getattr(entry, "created_at", 0) or 0
+            if now - float(created_at) < min_age_seconds:
+                too_fresh += 1
+                continue
+        scanned += 1
+        d = _decay_score(mf._storage, entry, now)
+        if d["forget_tendency"] < threshold:
+            continue
+        reasons = d["reasons"] or ["长期未使用，噪音淡出"]
+        mem_id = getattr(entry, "id", "")
+        if not dry_run:
+            ok = False
+            try:
+                if engine is not None:
+                    ok = bool(engine.storage.archive_memories_by_ids(
+                        [mem_id], reason="principled_forgetting", actor="gc") or 0)
+                if not ok:
+                    ok = bool(mf._storage.archive_memories_by_ids(
+                        [mem_id], reason="principled_forgetting", actor="gc") or 0)
+            except Exception:
+                try:
+                    ok = bool(mf._storage.archive_memories_by_ids(
+                        [mem_id], reason="principled_forgetting", actor="gc") or 0)
+                except Exception:
+                    ok = False
+        else:
+            ok = True
+        archived.append({
+            "memory_id": mem_id,
+            "content_preview": (getattr(entry, "content", "") or "")[:80],
+            "tendency": d["forget_tendency"],
+            "reasons": reasons,
+            "archived": ok,
+        })
+        if len(archived) >= 200:
+            break
+
+    return {
+        "success": True,
+        "dry_run": bool(dry_run),
+        "days": min_age_days,
+        "scanned": scanned,
+        "skipped_too_fresh": too_fresh,
+        "protected_high_importance": protected,
+        "candidates": len(archived),
+        "archived": sum(1 for a in archived if a["archived"]),
+        "decisions": archived[:50],
+        "threshold": threshold,
+    }
+
+
+def forgetting_stats(mf) -> Dict[str, Any]:
+    """遗忘引擎统计"""
+    stats = {"total_memories": 0, "archived": 0, "high_importance": 0,
+             "outcome_marked": 0, "explainable": True}
+    try:
+        conn = mf._storage._get_conn()
+        row = conn.execute("SELECT COUNT(*) FROM memories").fetchone()
+        stats["total_memories"] = row[0] if row else 0
+        row = conn.execute(
+            "SELECT COUNT(*) FROM memories WHERE importance = 'HIGH'").fetchone()
+        stats["high_importance"] = row[0] if row else 0
+        row = conn.execute(
+            "SELECT COUNT(*) FROM memories WHERE outcome != ''").fetchone()
+        stats["outcome_marked"] = row[0] if row else 0
+        row = conn.execute("SELECT COUNT(*) FROM archived_memories").fetchone()
+        stats["archived"] = row[0] if row else 0
+    except Exception:
+        pass
+    return stats