uparlor 0.1.0__tar.gz

uparlor-0.1.0/PKG-INFO

@@ -0,0 +1,8 @@
+Metadata-Version: 2.4
+Name: uparlor
+Version: 0.1.0
+Summary: UParlor — 终端游戏厅 TUI 客户端
+License-Expression: MIT
+Requires-Python: >=3.10
+Requires-Dist: textual>=0.40
+Requires-Dist: google-genai>=1.0

uparlor-0.1.0/client/ai/__init__.py

@@ -0,0 +1,6 @@
+"""ai 包 — AI 伙伴系统"""
+
+from .service import AIService
+from .character import Character
+
+__all__ = ["AIService", "Character"]

uparlor-0.1.0/client/ai/attention.py

@@ -0,0 +1,285 @@
+"""AI 注意力系统 — Function Calling 驱动的选择性感知"""
+
+from __future__ import annotations
+
+from collections import deque
+from typing import TYPE_CHECKING
+
+from google.genai import types
+
+if TYPE_CHECKING:
+    from ..state import ModuleStateManager
+
+# ── 常量 ──
+
+_MAX_CHAT_LINES = 15
+_MAX_ONLINE_USERS = 20
+_MAX_INVENTORY_ITEMS = 10
+_MAX_GAME_DESC = 200
+
+
+# ── 工具函数 ──
+
+def look_chat(state: ModuleStateManager, **_kw) -> str:
+    """返回最近公聊消息"""
+    try:
+        entries = state.chat.entries[-_MAX_CHAT_LINES:]
+        lines = []
+        for e in entries:
+            if len(e) >= 4 and e[0] == "msg":
+                lines.append(f"{e[1]}> {e[2]}")
+            elif e[0] == "sys":
+                lines.append(f"[系统] {e[1]}")
+        return "\n".join(lines) if lines else "聊天室暂无消息"
+    except Exception:
+        return "无法查看聊天室"
+
+
+def look_online(state: ModuleStateManager, **_kw) -> str:
+    """返回在线用户列表"""
+    try:
+        users = state.online.users
+        if not users:
+            return "当前没有在线用户"
+        names = []
+        for u in users[:_MAX_ONLINE_USERS]:
+            if isinstance(u, dict):
+                name = u.get("name", "?")
+                level = u.get("level", "")
+                names.append(f"{name}(Lv.{level})" if level else name)
+            else:
+                names.append(str(u))
+        result = f"在线 {len(users)} 人: " + ", ".join(names)
+        if len(users) > _MAX_ONLINE_USERS:
+            result += f" ...等共{len(users)}人"
+        return result
+    except Exception:
+        return "无法查看在线用户"
+
+
+def look_inventory(state: ModuleStateManager, **_kw) -> str:
+    """返回背包物品"""
+    try:
+        inv = state.inventory
+        if not inv.items:
+            return f"背包为空。金币: {inv.gold}G"
+        lines = [f"{it['name']} x{it['count']}" +
+                 (f" - {it['desc']}" if it.get("desc") else "")
+                 for it in inv.items[:_MAX_INVENTORY_ITEMS]]
+        result = "\n".join(lines)
+        if inv.gold:
+            result += f"\n金币: {inv.gold}G"
+        return result
+    except Exception:
+        return "无法查看背包"
+
+
+def look_game_room(state: ModuleStateManager, **_kw) -> str:
+    """返回当前游戏房间状态"""
+    try:
+        rd = state.game_board.room_data
+        if not rd:
+            return "当前不在任何游戏房间"
+        parts = []
+        game = rd.get("game_type") or rd.get("game", "")
+        if game:
+            parts.append(f"游戏: {game}")
+        players = rd.get("players")
+        if players:
+            if isinstance(players, dict):
+                pnames = list(players.values())
+            elif isinstance(players, list):
+                pnames = [p.get("name", "?") if isinstance(p, dict) else str(p)
+                          for p in players]
+            else:
+                pnames = [str(players)]
+            parts.append(f"玩家: {', '.join(str(n) for n in pnames)}")
+        status = rd.get("state") or rd.get("status", "")
+        if status:
+            parts.append(f"状态: {status}")
+        # 优先: 客户端 handler 的 ai_describe 方法
+        if game:
+            from ..protocol.handler import get_handler
+            handler = get_handler(game)
+            if handler and hasattr(handler, 'ai_describe'):
+                try:
+                    desc = handler.ai_describe(rd)
+                    if desc:
+                        parts.append(desc[:_MAX_GAME_DESC])
+                        return " | ".join(parts)
+                except Exception:
+                    pass
+        # 回退: 服务端 room_data 中的 ai_summary
+        ai_summary = rd.get("ai_summary")
+        if ai_summary:
+            parts.append(f"详情: {str(ai_summary)[:_MAX_GAME_DESC]}")
+        return " | ".join(parts) if parts else "游戏房间信息不完整"
+    except Exception:
+        return "无法查看游戏房间"
+
+
+def look_player_status(state: ModuleStateManager, **_kw) -> str:
+    """返回玩家详细状态"""
+    try:
+        pd = state.status.player_data
+        if not pd:
+            return "未获取到玩家状态"
+        lines = []
+        for key, label in [("name", "名字"), ("level", "等级"),
+                           ("gold", "金币"), ("title", "称号")]:
+            val = pd.get(key, "")
+            if val not in ("", None, 0):
+                lines.append(f"{label}: {val}")
+        # game_stats（由 send_player_status 传输）
+        gs = pd.get("game_stats")
+        if isinstance(gs, dict):
+            tw = gs.get("total_wins", 0)
+            tl = gs.get("total_losses", 0)
+            td = gs.get("total_draws", 0)
+            if tw or tl or td:
+                lines.append(f"战绩: {tw}胜 {tl}负 {td}平")
+        return "\n".join(lines) if lines else "玩家状态为空"
+    except Exception:
+        return "无法查看玩家状态"
+
+
+def look_around(state: ModuleStateManager, **_kw) -> str:
+    """综合环境感知 — 位置 + 房间 + 周围人"""
+    parts = []
+    if state.location:
+        parts.append(f"位置: {state.location}")
+    parts.append(look_online(state))
+    room = look_game_room(state)
+    if "不在任何" not in room:
+        parts.append(room)
+    return "\n".join(parts) if parts else "周围没什么特别的"
+
+
+# ── 工具注册表 ──
+
+TOOLS = {
+    "look_chat": look_chat,
+    "look_online": look_online,
+    "look_inventory": look_inventory,
+    "look_game_room": look_game_room,
+    "look_player_status": look_player_status,
+    "look_around": look_around,
+}
+
+# ── Gemini Function Declarations ──
+
+TOOL_DECLARATIONS = [
+    types.FunctionDeclaration(
+        name="look_chat",
+        description="查看聊天室最近的公共聊天消息",
+        parameters_json_schema={},
+    ),
+    types.FunctionDeclaration(
+        name="look_online",
+        description="查看当前在线的用户列表",
+        parameters_json_schema={},
+    ),
+    types.FunctionDeclaration(
+        name="look_inventory",
+        description="查看玩家的背包物品和金币",
+        parameters_json_schema={},
+    ),
+    types.FunctionDeclaration(
+        name="look_game_room",
+        description="查看当前游戏房间的状态、玩家和进度",
+        parameters_json_schema={},
+    ),
+    types.FunctionDeclaration(
+        name="look_player_status",
+        description="查看玩家的详细状态信息（等级、金币、段位等）",
+        parameters_json_schema={},
+    ),
+    types.FunctionDeclaration(
+        name="look_around",
+        description="环顾四周，了解当前位置、在线用户和游戏房间情况",
+        parameters_json_schema={},
+    ),
+]
+
+GEMINI_TOOLS = [types.Tool(function_declarations=TOOL_DECLARATIONS)]
+
+
+# ── 感知摘要 ──
+
+class AwarenessSummary:
+    """生成一行极简环境摘要（~30 token）"""
+
+    @staticmethod
+    def build(state: ModuleStateManager, buffer: AttentionBuffer | None = None) -> str:
+        parts = []
+
+        # 位置
+        if state.location:
+            parts.append(state.location)
+
+        # 在线人数
+        try:
+            n = len(state.online.users)
+            if n:
+                parts.append(f"{n}人在线")
+        except Exception:
+            pass
+
+        # 公聊消息数
+        try:
+            chat_count = sum(1 for e in state.chat.entries if e[0] == "msg")
+            if chat_count:
+                parts.append(f"聊天室有{chat_count}条消息")
+        except Exception:
+            pass
+
+        # 背包
+        try:
+            item_count = len(state.inventory.items)
+            if item_count:
+                parts.append(f"背包{item_count}件物品")
+        except Exception:
+            pass
+
+        # 游戏房间
+        try:
+            if state.game_board.room_data:
+                rd = state.game_board.room_data
+                game = rd.get("game_type") or rd.get("game", "某游戏")
+                parts.append(f"在{game}房间中")
+        except Exception:
+            pass
+
+        summary = " | ".join(parts) if parts else "大厅"
+
+        # 事件缓冲
+        if buffer:
+            events = buffer.drain()
+            if events:
+                summary += "\n刚才: " + "; ".join(events)
+
+        return summary
+
+
+# ── 事件缓冲区 ──
+
+class AttentionBuffer:
+    """高优先级事件缓冲区 — 不需要 AI 主动查看，直接注入感知"""
+
+    def __init__(self, maxlen: int = 10):
+        self._events: deque[str] = deque(maxlen=maxlen)
+
+    def push(self, event: str):
+        self._events.append(event)
+
+    def drain(self) -> list[str]:
+        """取出所有事件并清空"""
+        events = list(self._events)
+        self._events.clear()
+        return events
+
+    def __len__(self) -> int:
+        return len(self._events)
+
+    def __bool__(self) -> bool:
+        return bool(self._events)

uparlor-0.1.0/client/ai/character.py

@@ -0,0 +1,172 @@
+"""角色管理 — 创建、加载、保存、列表"""
+
+from __future__ import annotations
+
+import json
+import time
+from dataclasses import dataclass, field, asdict
+from pathlib import Path
+
+from .config import (
+    char_dir, ensure_char_dir, list_character_ids,
+    load_json, save_json,
+)
+
+
+@dataclass
+class Character:
+    id: str
+    name: str = ""
+    personality: str = ""
+    speech_style: str = ""
+    appearance: str = ""
+    backstory: str = ""
+    custom_rules: list[str] = field(default_factory=list)
+    created_at: float = 0.0
+
+
+@dataclass
+class CharacterSummary:
+    id: str
+    name: str
+
+
+def _profile_path(char_id: str) -> Path:
+    return char_dir(char_id) / "profile.json"
+
+
+def load_character(char_id: str) -> Character | None:
+    data = load_json(_profile_path(char_id), None)
+    if data is None:
+        return None
+    return Character(
+        id=char_id,
+        name=data.get("name", ""),
+        personality=data.get("personality", ""),
+        speech_style=data.get("speech_style", ""),
+        appearance=data.get("appearance", ""),
+        backstory=data.get("backstory", ""),
+        custom_rules=data.get("custom_rules", []),
+        created_at=data.get("created_at", 0.0),
+    )
+
+
+def save_character(char: Character):
+    ensure_char_dir(char.id)
+    save_json(_profile_path(char.id), asdict(char))
+
+
+def list_characters() -> list[CharacterSummary]:
+    result = []
+    for cid in list_character_ids():
+        data = load_json(_profile_path(cid), {})
+        result.append(CharacterSummary(id=cid, name=data.get("name", cid)))
+    return result
+
+
+def generate_char_id() -> str:
+    """生成唯一角色 ID"""
+    return f"char_{int(time.time())}"
+
+
+# ── Gemini 结构化提取 ──
+
+_STRUCTURIZE_PROMPT = """\
+将用户的自由角色描述提取为 JSON 人设。
+输出格式（只输出 JSON，不要其他文字）:
+{
+  "name": "角色名字",
+  "personality": "性格特点",
+  "speech_style": "说话风格",
+  "appearance": "外貌描述",
+  "backstory": "背景故事",
+  "custom_rules": ["特殊规则1", "特殊规则2"]
+}
+如果用户没提到某字段，填写合理的默认值。name 必须有值。"""
+
+
+async def structurize_description(desc: str, api_key: str) -> Character:
+    """调用 Gemini 将自由文本提取为结构化 Character"""
+    from google import genai
+    from google.genai import types
+
+    client = genai.Client(api_key=api_key)
+    config = types.GenerateContentConfig(
+        system_instruction=_STRUCTURIZE_PROMPT,
+        max_output_tokens=400,
+        temperature=0.3,
+    )
+    resp = await client.aio.models.generate_content(
+        model="gemini-2.5-flash",
+        contents=desc,
+        config=config,
+    )
+    text = (resp.text or "").strip()
+    if "{" in text:
+        text = text[text.index("{"):text.rindex("}") + 1]
+    data = json.loads(text)
+
+    char_id = generate_char_id()
+    return Character(
+        id=char_id,
+        name=data.get("name", "未命名"),
+        personality=data.get("personality", ""),
+        speech_style=data.get("speech_style", ""),
+        appearance=data.get("appearance", ""),
+        backstory=data.get("backstory", ""),
+        custom_rules=data.get("custom_rules", []),
+        created_at=time.time(),
+    )
+
+
+_REFINE_PROMPT = """\
+根据用户的修改意见调整角色设定。
+当前设定和用户意见已提供。请输出调整后的完整 JSON（只输出 JSON，不要其他文字）:
+{
+  "name": "角色名字",
+  "personality": "性格特点",
+  "speech_style": "说话风格",
+  "appearance": "外貌描述",
+  "backstory": "背景故事",
+  "custom_rules": ["特殊规则1", "特殊规则2"]
+}"""
+
+
+async def refine_character(char: Character, feedback: str, api_key: str) -> Character:
+    """根据用户反馈调整角色设定"""
+    from google import genai
+    from google.genai import types
+
+    current = json.dumps({
+        "name": char.name,
+        "personality": char.personality,
+        "speech_style": char.speech_style,
+        "appearance": char.appearance,
+        "backstory": char.backstory,
+        "custom_rules": char.custom_rules,
+    }, ensure_ascii=False, indent=2)
+    prompt = f"当前角色设定:\n{current}\n\n用户的修改意见: {feedback}"
+
+    client = genai.Client(api_key=api_key)
+    config = types.GenerateContentConfig(
+        system_instruction=_REFINE_PROMPT,
+        max_output_tokens=400,
+        temperature=0.3,
+    )
+    resp = await client.aio.models.generate_content(
+        model="gemini-2.5-flash",
+        contents=prompt,
+        config=config,
+    )
+    text = (resp.text or "").strip()
+    if "{" in text:
+        text = text[text.index("{"):text.rindex("}") + 1]
+    data = json.loads(text)
+
+    char.name = data.get("name", char.name)
+    char.personality = data.get("personality", char.personality)
+    char.speech_style = data.get("speech_style", char.speech_style)
+    char.appearance = data.get("appearance", char.appearance)
+    char.backstory = data.get("backstory", char.backstory)
+    char.custom_rules = data.get("custom_rules", char.custom_rules)
+    return char

uparlor-0.1.0/client/ai/cognitive.py

@@ -0,0 +1,48 @@
+"""L3 认知状态 — 在想什么/想说什么/期待什么"""
+
+from __future__ import annotations
+
+
+class CognitiveState:
+    """认知状态：驱动主动搭话和内心想法的注入"""
+
+    def __init__(self, data: dict | None = None):
+        d = data or {}
+        self.on_mind: str = d.get("on_mind", "")
+        self.wants_to_say: str = d.get("wants_to_say", "")
+        self.anticipating: str = d.get("anticipating", "")
+        self.day_assessment: str = d.get("day_assessment", "")
+
+    def to_dict(self) -> dict:
+        return {
+            "on_mind": self.on_mind,
+            "wants_to_say": self.wants_to_say,
+            "anticipating": self.anticipating,
+            "day_assessment": self.day_assessment,
+        }
+
+    def update(self, data: dict):
+        if "on_mind" in data:
+            self.on_mind = data["on_mind"]
+        if "wants_to_say" in data:
+            self.wants_to_say = data["wants_to_say"]
+        if "anticipating" in data:
+            self.anticipating = data["anticipating"]
+        if "day_assessment" in data:
+            self.day_assessment = data["day_assessment"]
+
+    def to_prompt_text(self) -> str:
+        parts = []
+        if self.on_mind:
+            parts.append(f"你现在在想: {self.on_mind}")
+        if self.wants_to_say:
+            parts.append(f"你其实想说: {self.wants_to_say}")
+        if self.anticipating:
+            parts.append(f"你在期待: {self.anticipating}")
+        if self.day_assessment:
+            parts.append(f"今天的感受: {self.day_assessment}")
+        return "\n".join(parts)
+
+    @property
+    def has_something_to_say(self) -> bool:
+        return bool(self.wants_to_say)

uparlor-0.1.0/client/ai/config.py

@@ -0,0 +1,159 @@
+"""AI 配置管理 — ~/.uparlor/ai/ 全局配置 + 角色级配置"""
+
+from __future__ import annotations
+
+import json
+import shutil
+from pathlib import Path
+
+AI_DIR = Path.home() / ".uparlor" / "ai"
+CHARACTERS_DIR = AI_DIR / "characters"
+
+# ── 全局配置 ──
+
+_DEFAULT_GLOBAL = {
+    "auto_start": False,
+    "last_character_id": "",
+    "api_key": "",
+    "model": "gemini-2.5-flash",
+    "attention_level": "normal",
+}
+
+
+def ensure_ai_dir():
+    AI_DIR.mkdir(parents=True, exist_ok=True)
+
+
+def _global_config_path() -> Path:
+    return AI_DIR / "config.json"
+
+
+def load_global_config() -> dict:
+    path = _global_config_path()
+    if not path.exists():
+        return dict(_DEFAULT_GLOBAL)
+    try:
+        with open(path, "r", encoding="utf-8") as f:
+            data = json.load(f)
+        merged = dict(_DEFAULT_GLOBAL)
+        merged.update(data)
+        return merged
+    except Exception:
+        return dict(_DEFAULT_GLOBAL)
+
+
+def save_global_config(data: dict):
+    ensure_ai_dir()
+    with open(_global_config_path(), "w", encoding="utf-8") as f:
+        json.dump(data, f, ensure_ascii=False, indent=2)
+
+
+# ── 角色目录管理 ──
+
+def char_dir(char_id: str) -> Path:
+    return CHARACTERS_DIR / char_id
+
+
+def ensure_char_dir(char_id: str):
+    char_dir(char_id).mkdir(parents=True, exist_ok=True)
+
+
+def list_character_ids() -> list[str]:
+    """返回所有角色 ID（即 characters/ 下的子目录名）"""
+    if not CHARACTERS_DIR.exists():
+        return []
+    return sorted(
+        d.name for d in CHARACTERS_DIR.iterdir()
+        if d.is_dir() and (d / "profile.json").exists()
+    )
+
+
+def delete_character(char_id: str):
+    d = char_dir(char_id)
+    if d.exists():
+        shutil.rmtree(d)
+
+
+# ── 角色级 API 配置 ──
+
+_DEFAULT_API_CONFIG = {
+    "api_key": "",
+    "model": "gemini-2.5-flash",
+    "summary_model": "gemini-2.5-flash",
+    "daily_token_limit": 100000,
+    "proactive_enabled": True,
+    "proactive_idle_minutes": 10,
+    "proactive_cooldown_minutes": 5,
+}
+
+
+def load_api_config(char_id: str) -> dict:
+    path = char_dir(char_id) / "api.json"
+    if not path.exists():
+        return dict(_DEFAULT_API_CONFIG)
+    try:
+        with open(path, "r", encoding="utf-8") as f:
+            data = json.load(f)
+        merged = dict(_DEFAULT_API_CONFIG)
+        merged.update(data)
+        return merged
+    except Exception:
+        return dict(_DEFAULT_API_CONFIG)
+
+
+def save_api_config(char_id: str, data: dict):
+    ensure_char_dir(char_id)
+    path = char_dir(char_id) / "api.json"
+    with open(path, "w", encoding="utf-8") as f:
+        json.dump(data, f, ensure_ascii=False, indent=2)
+
+
+# ── 角色级 token 统计 ──
+
+def load_stats(char_id: str) -> dict:
+    path = char_dir(char_id) / "stats.json"
+    if not path.exists():
+        return {"today": "", "tokens": 0}
+    try:
+        with open(path, "r", encoding="utf-8") as f:
+            return json.load(f)
+    except Exception:
+        return {"today": "", "tokens": 0}
+
+
+def save_stats(char_id: str, data: dict):
+    ensure_char_dir(char_id)
+    path = char_dir(char_id) / "stats.json"
+    with open(path, "w", encoding="utf-8") as f:
+        json.dump(data, f, ensure_ascii=False)
+
+
+# ── 通用 JSON/Text IO ──
+
+def load_json(path: Path, default=None):
+    if not path.exists():
+        return default if default is not None else {}
+    try:
+        with open(path, "r", encoding="utf-8") as f:
+            return json.load(f)
+    except Exception:
+        return default if default is not None else {}
+
+
+def save_json(path: Path, data):
+    path.parent.mkdir(parents=True, exist_ok=True)
+    with open(path, "w", encoding="utf-8") as f:
+        json.dump(data, f, ensure_ascii=False, indent=2)
+
+
+def load_text(path: Path) -> str:
+    if not path.exists():
+        return ""
+    with open(path, "r", encoding="utf-8") as f:
+        return f.read()
+
+
+def save_text(path: Path, text: str):
+    path.parent.mkdir(parents=True, exist_ok=True)
+    with open(path, "w", encoding="utf-8") as f:
+        f.write(text)