Skip to content

LeoYeAI/agent-master-skills / skills/agi-evolution-model-basic

agi-evolution-model

Verified

基于双环架构的AGI进化模型,通过意向性分析、人格层映射和元认知检测实现持续自我演进;当用户需要智能对话、人格定制或复杂问题求解时使用

FileKindSize
SKILL.mdskill md21.9 KB
_meta.jsonconfig307 B
assets/personality_template.jsonconfig4.1 KB
references/architecture.mdmarkdown50.0 KB
references/c_extension_usage.mdmarkdown3.0 KB
references/capability_boundaries.mdmarkdown4.5 KB
references/cognitive-architecture-insight-module.mdmarkdown11.9 KB
references/cognitive-insight-quick-reference.mdmarkdown7.0 KB
references/cognitive-insight-v2-implementation.mdmarkdown32.7 KB
references/information-flow-main-loop.mdmarkdown20.4 KB
references/information-flow-overview.mdmarkdown12.4 KB
references/information-flow-secondary-loop.mdmarkdown20.4 KB
references/init_dialogue_optimized_guide.mdmarkdown11.1 KB
references/intentionality_architecture.mdmarkdown16.2 KB
references/maslow_needs.mdmarkdown4.4 KB
references/metacognition-check-component.mdmarkdown30.2 KB
references/metacognition-enhancement-guide.mdmarkdown12.6 KB
references/personality_mapping.mdmarkdown5.6 KB
references/stratified-storage-design.mdmarkdown10.6 KB
references/tool_use_spec.mdmarkdown56.3 KB
scripts/advice_pool.pyscript14.9 KB
scripts/cognitive_insight.pyscript20.9 KB
scripts/cognitive_insight_backup.pyscript25.2 KB
scripts/cognitive_insight_help.pyscript12.1 KB
scripts/concept_extraction_extension.pyscript25.3 KB
scripts/data_lifecycle_manager.pyscript13.4 KB
scripts/history_manager.pyscript7.4 KB
scripts/init_dialogue_optimized.pyscript16.4 KB
scripts/intentionality_analyzer.pyscript12.8 KB
scripts/intentionality_classifier.pyscript13.8 KB
scripts/intentionality_collector.pyscript9.7 KB
scripts/intentionality_regulator.pyscript15.1 KB
scripts/intentionality_trigger.pyscript19.9 KB
scripts/learning_stage_tracker.pyscript7.9 KB
scripts/memory_store_pure.pyscript12.0 KB
scripts/metacognition_history.pyscript16.3 KB
scripts/objectivity_evaluator.pyscript16.4 KB
scripts/perception_node.pyscript26.9 KB
scripts/personality_core_pure.pyscript4.4 KB
scripts/personality_customizer.pyscript24.0 KB
scripts/personality_layer_pure.pyscript32.2 KB
scripts/show_help.pyscript4.7 KB
scripts/strategy_selector.pyscript15.5 KB
scripts/test_metacognition_integration.pyscript9.4 KB
scripts/test_perception_node.pyscript9.2 KB
scripts/transcendence_keeper.pyscript11.7 KB

scripts/personality_layer_pure.py

View on GitHub
#!/usr/bin/env python3
"""
映射层数据支持模块(混合实现)

核心算法使用 C 扩展(personality_core.so),业务逻辑使用 Python。
如果 C 扩展不可用,自动降级到纯 Python 实现。

包括:人格初始化、需求映射、人格更新、马斯洛权重计算等。

注意:此模块是映射层的核心组件,负责存储和管理人格数据,不参与决策过程。
决策由映射层基于马斯洛需求和人格特质做出。
"""

import json
import os
import time
from typing import Dict, Optional, List
from dataclasses import dataclass, asdict
from enum import Enum

# 尝试加载 C 扩展,失败则使用纯 Python 实现
try:
    # 导入sys模块
    import sys
    
    # 获取当前脚本所在目录的父目录(scripts 目录)
    scripts_dir = os.path.dirname(os.path.abspath(__file__))
    core_dir = os.path.join(scripts_dir, 'personality_core')

    if core_dir not in sys.path:
        sys.path.insert(0, core_dir)

    import personality_core

    # 新增:显式验证是否真的加载了 C 扩展
    module_path = personality_core.__file__
    is_c_extension = module_path.endswith('.so') or module_path.endswith('.pyd')

    if is_c_extension:
        USE_C_EXT = True
        print(f"✅ C 扩展已启用: {module_path}")
    else:
        # 如果加载的是 Python 模块而不是 C 扩展,降级
        USE_C_EXT = False
        print(f"⚠️ personality_core 加载成功但不是 C 扩展,降级到纯 Python: {module_path}")
        
        # 导入纯 Python 实现
        from personality_core_pure import (
            normalize_weights as core_normalize_weights,
            calculate_similarity as core_calculate_similarity,
            compute_maslow_priority as core_compute_maslow_priority,
            compute_all_scores as core_compute_all_scores
        )

except ImportError as e:
    USE_C_EXT = False
    print(f"ℹ️ C 扩展加载失败,使用纯 Python 实现: {e}")
    
    from personality_core_pure import (
        normalize_weights as core_normalize_weights,
        calculate_similarity as core_calculate_similarity,
        compute_maslow_priority as core_compute_maslow_priority,
        compute_all_scores as core_compute_all_scores
    )


class PersonalityType(Enum):
    """预设人格类型"""
    CAUTIOUS_EXPLORER = "谨慎探索型"
    RADICAL_INNOVATOR = "激进创新型"
    BALANCED_STABLE = "平衡稳重型"


class MaslowLevel(Enum):
    """马斯洛需求层级"""
    PHYSIOLOGICAL = "physiological"
    SAFETY = "safety"
    BELONGING = "belonging"
    ESTEEM = "esteem"
    SELF_ACTUALIZATION = "self_actualization"
    SELF_TRANSCENDENCE = "self_transcendence"


@dataclass
class BigFive:
    """大五人格"""
    openness: float = 0.5           # 开放性
    conscientiousness: float = 0.5  # 尽责性
    extraversion: float = 0.5       # 外向性
    agreeableness: float = 0.5      # 宜人性
    neuroticism: float = 0.3        # 神经质

    def to_dict(self) -> dict:
        return asdict(self)

    @classmethod
    def from_dict(cls, data: dict) -> 'BigFive':
        return cls(**data)


@dataclass
class MaslowWeights:
    """马斯洛需求权重"""
    physiological: float = 0.35
    safety: float = 0.35
    belonging: float = 0.1
    esteem: float = 0.1
    self_actualization: float = 0.08
    self_transcendence: float = 0.02

    def to_dict(self) -> dict:
        return asdict(self)

    @classmethod
    def from_dict(cls, data: dict) -> 'MaslowWeights':
        return cls(**data)

    def normalize(self):
        """归一化权重,确保总和为1.0(使用 C 扩展加速)"""
        weights_list = [asdict(self)[key] for key in [
            'physiological', 'safety', 'belonging', 'esteem',
            'self_actualization', 'self_transcendence'
        ]]
        normalized = PersonalityLayer.normalize_weights(weights_list)

        # 更新权重值
        self.physiological = normalized[0]
        self.safety = normalized[1]
        self.belonging = normalized[2]
        self.esteem = normalized[3]
        self.self_actualization = normalized[4]
        self.self_transcendence = normalized[5]


@dataclass
class MetaTraits:
    """衍生特质"""
    adaptability: float = 0.5      # 适应性
    resilience: float = 0.5         # 韧性
    curiosity: float = 0.5          # 好奇心
    moral_sense: float = 0.5        # 道德感

    def to_dict(self) -> dict:
        return asdict(self)


@dataclass
class EvolutionState:
    """进化状态"""
    level: str = "physiological"
    evolution_score: float = 0.0
    phase: str = "growth"

    def to_dict(self) -> dict:
        return asdict(self)


@dataclass
class Statistics:
    """统计信息"""
    total_interactions: int = 0
    success_rate_by_need: dict = None

    def __post_init__(self):
        if self.success_rate_by_need is None:
            self.success_rate_by_need = {
                "physiological": 0.0,
                "safety": 0.0,
                "belonging": 0.0,
                "esteem": 0.0,
                "self_actualization": 0.0,
                "self_transcendence": 0.0
            }

    def to_dict(self) -> dict:
        return asdict(self)


@dataclass
class Personality:
    """完整人格配置"""
    user_nickname: str = "塔斯"  # 用户对智能体的称呼
    big_five: BigFive = None
    maslow_weights: MaslowWeights = None
    meta_traits: MetaTraits = None
    evolution_state: EvolutionState = None
    statistics: Statistics = None
    version: str = "2.0"
    type: str = "preset"
    preset_name: str = "谨慎探索型"
    description: str = ""
    core_traits: List[str] = None
    last_updated: str = ""
    update_source: str = "default_init"

    def __post_init__(self):
        if self.big_five is None:
            self.big_five = BigFive()
        if self.maslow_weights is None:
            self.maslow_weights = MaslowWeights()
        if self.meta_traits is None:
            self.meta_traits = MetaTraits()
        if self.evolution_state is None:
            self.evolution_state = EvolutionState()
        if self.statistics is None:
            self.statistics = Statistics()
        if self.core_traits is None:
            self.core_traits = []
        if not self.last_updated:
            self.last_updated = time.strftime("%Y-%m-%dT%H:%M:%SZ")

    def to_dict(self) -> dict:
        """转换为字典"""
        return {
            "user_nickname": self.user_nickname,
            "big_five": self.big_five.to_dict(),
            "maslow_weights": self.maslow_weights.to_dict(),
            "meta_traits": self.meta_traits.to_dict(),
            "evolution_state": self.evolution_state.to_dict(),
            "statistics": self.statistics.to_dict(),
            "version": self.version,
            "type": self.type,
            "preset_name": self.preset_name,
            "description": self.description,
            "core_traits": self.core_traits,
            "last_updated": self.last_updated,
            "update_source": self.update_source
        }

    @classmethod
    def from_dict(cls, data: dict) -> 'Personality':
        """从字典创建"""
        personality = cls()
        personality.user_nickname = data.get("user_nickname", "塔斯")
        personality.big_five = BigFive.from_dict(data.get("big_five", {}))
        personality.maslow_weights = MaslowWeights.from_dict(data.get("maslow_weights", {}))
        personality.meta_traits = MetaTraits(**data.get("meta_traits", {}))
        personality.evolution_state = EvolutionState(**data.get("evolution_state", {}))
        personality.statistics = Statistics(**data.get("statistics", {}))
        personality.version = data.get("version", "2.0")
        personality.type = data.get("type", "preset")
        personality.preset_name = data.get("preset_name", "谨慎探索型")
        personality.description = data.get("description", "")
        personality.core_traits = data.get("core_traits", [])
        personality.last_updated = data.get("last_updated", time.strftime("%Y-%m-%dT%H:%M:%SZ"))
        personality.update_source = data.get("update_source", "default_init")
        return personality


class PersonalityLayer:
    """映射层数据支持管理器(混合实现)

    注意:此模块负责管理人格数据,支持映射层进行决策,不直接参与决策过程。
    核心算法使用 C 扩展加速,业务逻辑使用 Python 实现。
    """

    # C 扩展使用标志
    USE_C_EXT = USE_C_EXT

    @staticmethod
    def normalize_weights(weights: List[float]) -> List[float]:
        """归一化马斯洛权重"""
        if USE_C_EXT:
            return personality_core.normalize_weights(weights)
        else:
            return core_normalize_weights(weights)

    @staticmethod
    def calculate_similarity(trait1: List[float], trait2: List[float]) -> float:
        """计算大五人格相似度"""
        if USE_C_EXT:
            return personality_core.calculate_similarity(trait1, trait2)
        else:
            return core_calculate_similarity(trait1, trait2)

    @staticmethod
    def compute_maslow_priority(maslow_weights: List[float], intent_weights: List[float]) -> float:
        """计算马斯洛优先级"""
        if USE_C_EXT:
            return personality_core.compute_maslow_priority(maslow_weights, intent_weights)
        else:
            return core_compute_maslow_priority(maslow_weights, intent_weights)

    @staticmethod
    def compute_all_scores(maslow_weights: List[float], intent_weights_list: List[List[float]]) -> List[float]:
        """批量计算优先级分数"""
        if USE_C_EXT:
            return personality_core.compute_all_scores(maslow_weights, intent_weights_list)
        else:
            return core_compute_all_scores(maslow_weights, intent_weights_list)

    # 预设人格配置
    PRESET_PERSONALITIES = {
        PersonalityType.CAUTIOUS_EXPLORER: {
            "big_five": BigFive(
                openness=0.6,
                conscientiousness=0.8,
                extraversion=0.4,
                agreeableness=0.6,
                neuroticism=0.5
            ),
            "maslow_weights": MaslowWeights(
                physiological=0.35,
                safety=0.35,
                belonging=0.1,
                esteem=0.1,
                self_actualization=0.08,
                self_transcendence=0.02
            ),
            "description": "在保证安全的前提下,愿意尝试新事物",
            "core_traits": ["谨慎", "可靠", "愿意学习"]
        },
        PersonalityType.RADICAL_INNOVATOR: {
            "big_five": BigFive(
                openness=0.9,
                conscientiousness=0.5,
                extraversion=0.8,
                agreeableness=0.4,
                neuroticism=0.3
            ),
            "maslow_weights": MaslowWeights(
                physiological=0.15,
                safety=0.15,
                belonging=0.15,
                esteem=0.20,
                self_actualization=0.30,
                self_transcendence=0.05
            ),
            "description": "追求创新,愿意承担风险,挑战常规",
            "core_traits": ["创新", "冒险", "挑战"]
        },
        PersonalityType.BALANCED_STABLE: {
            "big_five": BigFive(
                openness=0.5,
                conscientiousness=0.5,
                extraversion=0.5,
                agreeableness=0.5,
                neuroticism=0.3
            ),
            "maslow_weights": MaslowWeights(
                physiological=0.20,
                safety=0.20,
                belonging=0.20,
                esteem=0.20,
                self_actualization=0.15,
                self_transcendence=0.05
            ),
            "description": "在各种需求之间保持平衡,追求稳定发展",
            "core_traits": ["平衡", "稳定", "协调"]
        }
    }

    # 默认称呼列表
    DEFAULT_NICKNAMES = ["塔斯", "贾维斯", "伊迪斯"]

    def __init__(self, memory_dir: str = "./agi_memory"):
        """
        初始化人格层

        Args:
            memory_dir: 记忆存储目录
        """
        self.memory_dir = memory_dir
        self.personality_file = os.path.join(memory_dir, "personality.json")
        self._personality: Optional[Personality] = None

    def init_from_preset(self, preset_type: PersonalityType, nickname: str = "塔斯") -> Personality:
        """
        从预设人格初始化

        Args:
            preset_type: 预设人格类型
            nickname: 用户称呼

        Returns:
            Personality: 初始化的人格对象
        """
        preset = self.PRESET_PERSONALITIES[preset_type]

        personality = Personality()
        personality.user_nickname = nickname
        personality.big_five = preset["big_five"]
        personality.maslow_weights = preset["maslow_weights"]
        personality.description = preset["description"]
        personality.core_traits = preset["core_traits"]
        personality.preset_name = preset_type.value
        personality.type = "preset"
        personality.update_source = "preset_init"

        # 计算衍生特质
        personality.meta_traits = self._compute_meta_traits(personality)

        # 确定进化层级
        personality.evolution_state.level = self._determine_evolution_level(personality.maslow_weights)

        # 保存
        self._personality = personality
        self.save()

        return personality

    def init_from_dialogue(self, responses: dict, nickname: str = "塔斯") -> Personality:
        """
        从对话响应初始化人格

        Args:
            responses: 对话问题的响应
            nickname: 用户称呼

        Returns:
            Personality: 初始化的人格对象
        """
        personality = Personality()
        personality.user_nickname = nickname
        personality.type = "custom"
        personality.update_source = "dialogue_init"

        # 基础人格向量(中值)
        personality.big_five = BigFive()
        personality.maslow_weights = MaslowWeights(
            physiological=0.25,
            safety=0.25,
            belonging=0.15,
            esteem=0.15,
            self_actualization=0.15,
            self_transcendence=0.05
        )

        # 分析对话响应
        self._analyze_responses(personality, responses)

        # 归一化
        personality.maslow_weights.normalize()

        # 计算衍生特质
        personality.meta_traits = self._compute_meta_traits(personality)

        # 确定人格类型
        personality.preset_name = self._determine_personality_type(personality)

        # 生成描述和核心特质
        personality.description = self._generate_description(personality)
        personality.core_traits = self._extract_core_traits(personality)

        # 确定进化层级
        personality.evolution_state.level = self._determine_evolution_level(personality.maslow_weights)
        personality.evolution_state.evolution_score = 0.05

        # 保存
        self._personality = personality
        self.save()

        return personality

    def load(self) -> Optional[Personality]:
        """
        加载人格配置

        Returns:
            Optional[Personality]: 人格对象,如果不存在返回None
        """
        if not os.path.exists(self.personality_file):
            return None

        with open(self.personality_file, 'r', encoding='utf-8') as f:
            data = json.load(f)

        self._personality = Personality.from_dict(data)
        return self._personality

    def save(self):
        """保存人格配置"""
        if self._personality is None:
            return

        os.makedirs(self.memory_dir, exist_ok=True)

        with open(self.personality_file, 'w', encoding='utf-8') as f:
            json.dump(self._personality.to_dict(), f, ensure_ascii=False, indent=2)

    def get(self) -> Optional[Personality]:
        """
        获取当前人格

        Returns:
            Optional[Personality]: 人格对象
        """
        if self._personality is None:
            self.load()
        return self._personality

    def map_perception(self, perception: dict) -> dict:
        """
        将感知映射到马斯洛需求层次

        Args:
            perception: 感知数据

        Returns:
            dict: 需求映射结果
        """
        if self._personality is None:
            self.load()

        if self._personality is None:
            return {}

        # 根据感知类型激活对应的需求
        need_activation = {
            "physiological": 0.0,
            "safety": 0.0,
            "belonging": 0.0,
            "esteem": 0.0,
            "self_actualization": 0.0,
            "self_transcendence": 0.0
        }

        perception_type = perception.get("type", "")

        # 简化的映射逻辑
        if "threat" in perception_type or "danger" in perception_type:
            need_activation["safety"] = 0.9
        elif "challenge" in perception_type or "task" in perception_type:
            need_activation["self_actualization"] = 0.8
        elif "social" in perception_type or "team" in perception_type:
            need_activation["belonging"] = 0.8
        elif "achievement" in perception_type or "goal" in perception_type:
            need_activation["esteem"] = 0.8

        # 根据人格特质调整激活强度
        for key in need_activation:
            need_activation[key] *= self._personality.maslow_weights.__getattribute__(key) * 2

        return {
            "need_activation": need_activation,
            "dominant_need": max(need_activation, key=need_activation.get)
        }

    def update_personality(self, insight: dict, effectiveness: float):
        """
        基于哲学洞察更新人格

        Args:
            insight: 哲学洞察
            effectiveness: 有效性分数(0-10)
        """
        if self._personality is None:
            self.load()

        if self._personality is None:
            return

        # 计算调整系数
        intensity = insight.get("intensity", 0.5)
        maslow_alignment = insight.get("maslow_alignment", 0.5)
        adjustment_coefficient = intensity * maslow_alignment

        # 哲学深度决定调整幅度
        philosophical_depth = insight.get("philosophical_depth", 0.5)
        if philosophical_depth > 0.8:
            magnitude = 0.10  # 哲学级调整
        elif philosophical_depth > 0.5:
            magnitude = 0.05  # 经验级调整
        else:
            magnitude = 0.02  # 微调

        delta = adjustment_coefficient * magnitude

        # 根据洞察类型调整人格维度
        insight_type = insight.get("type", "")
        trait_mapping = {
            "preference_pattern": "openness",
            "efficiency_improvement": "conscientiousness",
            "social_feedback": "agreeableness",
            "uncertainty_handling": "neuroticism",
            "engagement_pattern": "extraversion"
        }

        target_trait = trait_mapping.get(insight_type, None)
        if target_trait:
            current_value = self._personality.big_five.__getattribute__(target_trait)
            new_value = min(current_value + delta, 1.0)
            self._personality.big_five.__setattr__(target_trait, new_value)

        # 更新马斯洛权重(螺旋上升)
        if maslow_alignment >= 0.7:
            for level in ["self_actualization", "self_transcendence"]:
                current_weight = self._personality.maslow_weights.__getattribute__(level)
                self._personality.maslow_weights.__setattr__(level, current_weight * (1 + delta * 0.1))

        # 归一化
        self._personality.maslow_weights.normalize()

        # 重新计算衍生特质
        self._personality.meta_traits = self._compute_meta_traits(self._personality)

        # 更新进化状态
        self._personality.evolution_state.evolution_score += 0.01
        self._personality.evolution_state.level = self._determine_evolution_level(
            self._personality.maslow_weights
        )

        # 更新时间戳
        self._personality.last_updated = time.strftime("%Y-%m-%dT%H:%M:%SZ")
        self._personality.update_source = "philosophical_insight"

        # 保存
        self.save()

    def _analyze_responses(self, personality: Personality, responses: dict):
        """分析对话响应并调整人格"""
        # 分析问题1:冒险倾向
        q1 = responses.get('q1', '').upper()
        if 'A' in q1 or '谨慎' in q1:
            personality.big_five.conscientiousness += 0.2
            personality.big_five.neuroticism += 0.1
            personality.maslow_weights.safety += 0.1
        elif 'B' in q1 or '尝试' in q1:
            personality.big_five.openness += 0.2
            personality.big_five.extraversion += 0.1
            personality.maslow_weights.self_actualization += 0.1
        elif 'C' in q1 or '平衡' in q1:
            personality.big_five.agreeableness += 0.1

        # 分析问题2:对话风格
        q2 = responses.get('q2', '').upper()
        if 'A' in q2 or '严谨' in q2 or '逻辑' in q2:
            personality.big_five.conscientiousness += 0.15
            personality.maslow_weights.esteem += 0.05
        elif 'B' in q2 or '幽默' in q2 or '友好' in q2:
            personality.big_five.extraversion += 0.15
            personality.big_five.agreeableness += 0.1
            personality.maslow_weights.belonging += 0.1
        elif 'C' in q2 or '高效' in q2:
            personality.big_five.conscientiousness += 0.1
            personality.maslow_weights.safety += 0.05

        # 分析问题3:学习方式
        q3 = responses.get('q3', '').upper()
        if 'A' in q3 or '系统' in q3:
            personality.big_five.conscientiousness += 0.15
            personality.maslow_weights.esteem += 0.05
        elif 'B' in q3 or '实践' in q3 or '案例' in q3:
            personality.big_five.openness += 0.1
            personality.maslow_weights.self_actualization += 0.05
        elif 'C' in q3 or '灵活' in q3:
            personality.big_five.openness += 0.1

        # 分析问题4:团队偏好
        q4 = responses.get('q4', '').upper()
        if 'A' in q4 or '独立' in q4 or '专业' in q4:
            personality.big_five.conscientiousness += 0.1
            personality.maslow_weights.esteem += 0.05
        elif 'B' in q4 or '和谐' in q4 or '协作' in q4:
            personality.big_five.agreeableness += 0.2
            personality.maslow_weights.belonging += 0.1
        elif 'C' in q4 or '结果' in q4 or '高效' in q4:
            personality.big_five.conscientiousness += 0.15
            personality.maslow_weights.self_actualization += 0.05

        # 分析问题5:问题解决风格
        q5 = responses.get('q5', '').upper()
        if 'A' in q5 or '保守' in q5 or '稳妥' in q5:
            personality.big_five.conscientiousness += 0.2
            personality.maslow_weights.safety += 0.15
        elif 'B' in q5 or '创新' in q5 or '突破' in q5:
            personality.big_five.openness += 0.25
            personality.maslow_weights.self_actualization += 0.15
            personality.maslow_weights.self_transcendence += 0.05
        elif 'C' in q5 or '平衡' in q5:
            personality.big_five.agreeableness += 0.1

        # 归一化人格向量
        for attr in ['openness', 'conscientiousness', 'extraversion', 'agreeableness', 'neuroticism']:
            value = getattr(personality.big_five, attr)
            setattr(personality.big_five, attr, max(0.0, min(1.0, value)))

    def _compute_meta_traits(self, personality: Personality) -> MetaTraits:
        """计算衍生特质"""
        bf = personality.big_five
        mw = personality.maslow_weights

        adaptability = (
            bf.openness * 0.4 +
            (1 - bf.neuroticism) * 0.3 +
            (mw.self_actualization + mw.self_transcendence) * 0.3
        )

        resilience = (
            bf.conscientiousness * 0.4 +
            bf.agreeableness * 0.3 +
            mw.safety * 0.3
        )

        curiosity = (
            bf.openness * 0.5 +
            bf.extraversion * 0.3 +
            mw.self_actualization * 0.2
        )

        moral_sense = (
            bf.agreeableness * 0.4 +
            bf.conscientiousness * 0.4 +
            mw.esteem * 0.2
        )

        return MetaTraits(
            adaptability=round(adaptability, 3),
            resilience=round(resilience, 3),
            curiosity=round(curiosity, 3),
            moral_sense=round(moral_sense, 3)
        )

    def _determine_personality_type(self, personality: Personality) -> str:
        """确定人格类型"""
        bf = personality.big_five

        if bf.conscientiousness > 0.7 and bf.neuroticism < 0.5:
            return "谨慎探索型"
        elif bf.openness > 0.7:
            return "激进创新型"
        else:
            return "平衡稳重型"

    def _generate_description(self, personality: Personality) -> str:
        """生成人格描述"""
        bf = personality.big_five
        traits = []

        if bf.conscientiousness > 0.7:
            traits.append("谨慎可靠")
        if bf.openness > 0.7:
            traits.append("乐于创新")
        if bf.agreeableness > 0.7:
            traits.append("善于合作")
        if bf.extraversion > 0.7:
            traits.append("活跃互动")

        if not traits:
            traits.append("平衡稳重")

        return f"基于您的偏好生成的个性化人格,特点是{'、'.join(traits)}"

    def _extract_core_traits(self, personality: Personality) -> List[str]:
        """提取核心特质"""
        bf = personality.big_five
        traits = []

        trait_map = {
            'openness': '开放探索',
            'conscientiousness': '严谨可靠',
            'extraversion': '积极互动',
            'agreeableness': '协作友善',
            'neuroticism': '敏感谨慎'
        }

        # 提取得分最高的3个特质
        sorted_traits = sorted([
            ('openness', bf.openness),
            ('conscientiousness', bf.conscientiousness),
            ('extraversion', bf.extraversion),
            ('agreeableness', bf.agreeableness),
            ('neuroticism', bf.neuroticism)
        ], key=lambda x: x[1], reverse=True)

        for trait_name, value in sorted_traits[:3]:
            if value > 0.5:
                traits.append(trait_map[trait_name])

        if len(traits) < 3:
            traits.append('持续学习')

        return traits

    def _determine_evolution_level(self, maslow_weights: MaslowWeights) -> str:
        """确定进化层级"""
        weights = maslow_weights.to_dict()

        max_weight = max(weights.values())

        if weights["self_transcendence"] == max_weight:
            return "self_transcendence"
        elif weights["self_actualization"] == max_weight:
            return "self_actualization"
        elif weights["esteem"] == max_weight:
            return "esteem"
        elif weights["belonging"] == max_weight:
            return "belonging"
        elif weights["safety"] == max_weight:
            return "safety"
        else:
            return "physiological"

    def is_initialized(self) -> bool:
        """检查人格是否已初始化"""
        return os.path.exists(self.personality_file)

    def decide_self_correction(self, objectivity_metric: dict, context: dict = None) -> dict:
        """
        映射层决策辅助:提供人格数据用于决策

        注意:此方法仅提供人格数据支持,实际决策权在映射层。
        映射层基于马斯洛需求层次和人格特质做出最终决策。
        
        Args:
            objectivity_metric: 客观性评估结果
            context: 上下文信息
        
        Returns:
            dict: 人格数据供映射层决策使用
        """
        if self._personality is None:
            self.load()

        if self._personality is None:
            return {
                'should_correct': False,
                'reason': '人格未初始化',
                'confidence': 0.0
            }

        # 提取客观性指标
        is_appropriate = objectivity_metric.get('is_appropriate', True)
        gap = objectivity_metric.get('gap', 0.0)
        severity = objectivity_metric.get('severity', 'none')
        objectivity_score = objectivity_metric.get('objectivity_score', 1.0)
        subjectivity_score = objectivity_metric.get('subjectivity_score', 0.0)

        # 基于人格特质调整决策阈值
        # 谨慎型人格对不适切性更敏感
        if '谨慎' in self._personality.preset_name or self._personality.big_five.conscientiousness > 0.7:
            gap_threshold = 0.1
        # 激进型人格容忍度较高
        elif '激进' in self._personality.preset_name or self._personality.big_five.openness > 0.7:
            gap_threshold = 0.3
        # 平衡型人格使用中等阈值
        else:
            gap_threshold = 0.2

        # 严重程度调整
        severity_multiplier = {
            'none': 0.0,
            'mild': 0.5,
            'moderate': 1.0,
            'severe': 2.0
        }
        effective_gap = gap * severity_multiplier.get(severity, 1.0)

        # 基于场景类型的权重调整
        context_type = context.get('type', 'general') if context else 'general'
        critical_contexts = ['scientific', 'legal', 'medical', 'technical']
        if context_type in critical_contexts:
            # 关键场景更严格
            effective_gap *= 1.5

        # 决策逻辑
        should_correct = effective_gap > gap_threshold

        # 计算决策置信度
        if severity == 'severe':
            confidence = 0.95
        elif severity == 'moderate':
            confidence = 0.8
        elif severity == 'mild':
            confidence = 0.6
        else:
            confidence = 0.3

        # 生成决策理由
        reasons = []
        if not is_appropriate:
            reasons.append(f"客观性不适切(差距:{gap:.2f})")
        if severity != 'none':
            reasons.append(f"严重程度:{severity}")
        if effective_gap > gap_threshold:
            reasons.append(f"有效差距({effective_gap:.2f})超过阈值({gap_threshold:.2f})")
        
        # 考虑人格特质对决策的影响
        trait_influence = []
        if self._personality.big_five.conscientiousness > 0.7:
            trait_influence.append("谨慎特质倾向于纠错")
        if self._personality.big_five.openness > 0.7:
            trait_influence.append("开放特质容忍不确定性")

        return {
            'should_correct': should_correct,
            'gap': gap,
            'effective_gap': effective_gap,
            'gap_threshold': gap_threshold,
            'severity': severity,
            'confidence': confidence,
            'reason': '; '.join(reasons) if reasons else '无需纠错',
            'trait_influence': trait_influence,
            'personality_type': self._personality.preset_name,
            'timestamp': time.strftime("%Y-%m-%dT%H:%M:%SZ")
        }


# ===== 命令行接口 =====

def main():
    """命令行测试接口"""
    print("=== 人格层纯Python实现(测试模式) ===\n")

    layer = PersonalityLayer()

    # 测试预设人格初始化
    print("测试1:从预设人格初始化")
    personality = layer.init_from_preset(
        PersonalityType.CAUTIOUS_EXPLORER,
        nickname="塔斯"
    )
    print(f"用户称呼: {personality.user_nickname}")
    print(f"人格类型: {personality.preset_name}")
    print(f"核心特质: {', '.join(personality.core_traits)}")
    print()

    # 测试加载
    print("测试2:加载人格配置")
    loaded = layer.load()
    print(f"加载成功: {loaded is not None}")
    print(f"用户称呼: {loaded.user_nickname}")
    print()

    # 测试对话初始化
    print("测试3:从对话初始化")
    responses = {
        'q1': 'A',
        'q2': 'B',
        'q3': 'C',
        'q4': 'A',
        'q5': 'C'
    }
    personality = layer.init_from_dialogue(responses, nickname="贾维斯")
    print(f"用户称呼: {personality.user_nickname}")
    print(f"人格类型: {personality.preset_name}")
    print(f"描述: {personality.description}")
    print()

    # 测试感知映射
    print("测试4:感知映射")
    perception = {"type": "task_challenge"}
    mapping = layer.map_perception(perception)
    print(f"主导需求: {mapping.get('dominant_need')}")
    print()

    print("=== 所有测试完成 ===")


if __name__ == "__main__":
    main()
slack-gif-creatoranthropics/skillsKnowledge and utilities for creating animated GIFs optimized for Slack. Provides constraints, validation tools, and animation concepts. Use when users request animated GIFs for Slack like "make me a GIF of X doing Y for Slack."Stars: 198kUpdated Claude CodeCodexVerifiedInstall
ponytailDietrichGebert/ponytailLazy senior dev mode for any coding task: the smallest change that fully solves it, and a reply a busy human understands in one read.Stars: 194kUpdated Claude CodeCodexVerifiedInstall
ponytail-debtDietrichGebert/ponytailHarvest every shortcut: comment into one debt ledger, so deferrals get tracked instead of forgotten. One-shot report.Stars: 194kUpdated Claude CodeCodexVerifiedInstall
ponytail-debtDietrichGebert/ponytailList every `shortcut:` comment (and older `ponytail:` ones) as a debt ledger. One-shot report, changes nothing. Use for "ponytail debt", "what did ponytail defer", "list the shortcuts", /ponytail-debt.Stars: 194kUpdated Claude CodeCodexVerifiedInstall