chcode 0.1.0__py3-none-any.whl

chcode/session.py

@@ -0,0 +1,149 @@
+"""
+会话管理 — thread_id, checkpointer DB, 历史会话列表/加载/删除/重命名
+"""
+
+from __future__ import annotations
+
+import asyncio
+import json
+from datetime import datetime
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+from rich.console import Console
+
+if TYPE_CHECKING:
+    from langgraph.graph.state import CompiledStateGraph
+    from langgraph.checkpoint.sqlite.aio import AsyncSqliteSaver
+
+from langchain_core.messages import HumanMessage
+
+console = Console()
+
+_SUMMARY_MAX_LEN = 40
+
+
+class SessionManager:
+    def __init__(self, workplace_path: Path):
+        self.workplace_path = workplace_path
+        self.sessions_dir = workplace_path / ".chat" / "sessions"
+        self.sessions_dir.mkdir(parents=True, exist_ok=True)
+        self.thread_id = self._new_thread_id()
+        self._names_path = self.sessions_dir / "names.json"
+
+    # ─── names.json 读写 ─────────────────────────────────
+
+    def _load_names(self) -> dict[str, str]:
+        if self._names_path.exists():
+            try:
+                return json.loads(self._names_path.read_text("utf-8"))
+            except Exception:
+                return {}
+        return {}
+
+    def _save_names(self, names: dict[str, str]) -> None:
+        self._names_path.write_text(
+            json.dumps(names, ensure_ascii=False, indent=2), "utf-8"
+        )
+
+    # ─── 基础 ────────────────────────────────────────────
+
+    def _new_thread_id(self) -> str:
+        return f"thread_{datetime.now().strftime('%Y%m%d_%H%M%S_%f')}"
+
+    @property
+    def config(self) -> dict:
+        return {"configurable": {"thread_id": self.thread_id}}
+
+    def new_session(self) -> None:
+        self.thread_id = self._new_thread_id()
+
+    def set_thread(self, thread_id: str) -> None:
+        self.thread_id = thread_id
+
+    # ─── 重命名 ──────────────────────────────────────────
+
+    def rename_session(self, thread_id: str, new_name: str) -> None:
+        names = self._load_names()
+        if new_name:
+            names[thread_id] = new_name
+        else:
+            names.pop(thread_id, None)
+        self._save_names(names)
+
+    # ─── 显示名 ──────────────────────────────────────────
+
+    async def _get_summary(
+        self, agent: CompiledStateGraph, thread_id: str
+    ) -> str | None:
+        cfg = {"configurable": {"thread_id": thread_id}}
+        try:
+            from chcode.utils import get_text_content
+            state = await agent.aget_state(cfg)
+            messages = state.values.get("messages", [])
+            for msg in messages:
+                if isinstance(msg, HumanMessage):
+                    if not isinstance(msg.content, (str, list)):
+                        continue
+                    text = get_text_content(msg.content)
+                    text = text.strip().replace("\n", " ")
+                    if text:
+                        return text[:_SUMMARY_MAX_LEN] + (
+                            "…" if len(text) > _SUMMARY_MAX_LEN else ""
+                        )
+        except Exception:
+            pass
+        return None
+
+    async def get_display_names(
+        self,
+        thread_ids: list[str],
+        agent: CompiledStateGraph,
+    ) -> dict[str, str]:
+        names = self._load_names()
+        result: dict[str, str] = {}
+        need_summary: list[str] = []
+
+        for tid in thread_ids:
+            if tid in names:
+                result[tid] = names[tid]
+            else:
+                need_summary.append(tid)
+
+        if need_summary:
+            summaries = await asyncio.gather(
+                *[self._get_summary(agent, tid) for tid in need_summary]
+            )
+            for tid, summary in zip(need_summary, summaries):
+                result[tid] = summary or tid
+
+        return result
+
+    # ─── 列表 / 删除 ─────────────────────────────────────
+
+    async def list_sessions(self, checkpointer: AsyncSqliteSaver) -> list[str]:
+        """从 checkpointer 获取所有历史 thread_id"""
+        try:
+            await checkpointer.setup()
+            async with checkpointer.lock:
+                rows = await checkpointer.conn.execute_fetchall(
+                    "SELECT DISTINCT thread_id FROM checkpoints"
+                )
+            return [row[0] for row in rows if row[0]]
+        except Exception:
+            return []
+
+    async def delete_session(
+        self, thread_id: str, checkpointer: AsyncSqliteSaver
+    ) -> bool:
+        """删除指定会话的所有数据"""
+        try:
+            await checkpointer.adelete_thread(thread_id)
+            names = self._load_names()
+            if thread_id in names:
+                del names[thread_id]
+                self._save_names(names)
+            return True
+        except Exception as e:
+            console.print(f"[red]删除会话失败: {e}[/red]")
+            return False

chcode/skill_manager.py

@@ -0,0 +1,165 @@
+"""
+技能管理 — 扫描/列表/查看详情/安装/删除，全部用下拉列表交互
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+from rich.console import Console
+from rich.panel import Panel
+from rich.markdown import Markdown
+from rich.table import Table
+
+from chcode.prompts import select, confirm, text
+from chcode.utils.skill_loader import (
+    scan_all_skills,
+    validate_skill_package,
+    install_skill,
+)
+
+if TYPE_CHECKING:
+    from chcode.session import SessionManager
+
+console = Console()
+
+
+async def manage_skills(session: SessionManager) -> None:
+    """技能管理主菜单"""
+    while True:
+        action = await select(
+            "技能管理:",
+            ["查看已安装技能", "安装新技能", "返回"],
+        )
+        if action is None or action == "返回":
+            return
+
+        if action == "查看已安装技能":
+            await _list_skills(session)
+        elif action == "安装新技能":
+            await _install_skill(session)
+
+
+async def _list_skills(session: SessionManager) -> None:
+    """列出所有已安装技能，支持下拉选择操作"""
+    skills = scan_all_skills(session.workplace_path)
+    if not skills:
+        console.print("[yellow]没有发现已安装的技能[/yellow]")
+        return
+
+    # 构建表格
+    table = Table(title="已安装技能")
+    table.add_column("名称", style="cyan")
+    table.add_column("类型", style="green")
+    table.add_column("描述", style="white")
+    table.add_column("路径", style="dim")
+    for s in skills:
+        desc = s["description"]
+        if len(desc) > 60:
+            desc = desc[:57] + "..."
+        table.add_row(s["name"], s["type"], desc, str(s["path"]))
+    console.print(table)
+
+    # 选择操作
+    names = [f"{s['name']} ({s['type']})" for s in skills]
+    action = await select(
+        "选择技能进行操作:",
+        names + ["返回"],
+    )
+    if action is None or action == "返回":
+        return
+
+    # 找到选中的技能
+    selected_name = action.split(" (")[0]
+    skill = next((s for s in skills if s["name"] == selected_name), None)
+    if not skill:
+        return
+
+    op = await select(
+        f"对技能 '{skill['name']}' 的操作:",
+        ["查看详情", "删除技能", "返回"],
+    )
+    if op == "查看详情":
+        await _show_skill_detail(skill)
+    elif op == "删除技能":
+        await _delete_skill(skill, session)
+    elif op == "返回":
+        return
+
+
+async def _show_skill_detail(skill: dict) -> None:
+    """查看技能详情"""
+    skill_md = Path(skill["path"]) / "SKILL.md"
+    if not skill_md.exists():
+        console.print("[red]技能文件不存在[/red]")
+        return
+
+    content = skill_md.read_text(encoding="utf-8")
+    console.print(
+        Panel(
+            Markdown(content),
+            title=f"技能: {skill['name']}",
+            border_style="cyan",
+            padding=(1, 2),
+        )
+    )
+
+
+async def _delete_skill(skill: dict, session: SessionManager) -> None:
+    """删除技能"""
+    ok = await confirm(
+        f"确定删除技能 '{skill['name']}'？此操作不可撤销！", default=False
+    )
+    if not ok:
+        return
+
+    import shutil
+
+    skill_path = Path(skill["path"])
+    try:
+        shutil.rmtree(skill_path)
+        console.print(f"[green]技能 '{skill['name']}' 已删除[/green]")
+    except Exception as e:
+        console.print(f"[red]删除失败: {e}[/red]")
+
+
+async def _install_skill(session: SessionManager) -> None:
+    """安装技能"""
+    file_path = await text("输入技能压缩包路径 (.zip/.tar.gz/.tgz):")
+    if not file_path:
+        return
+
+    path = Path(file_path)
+    if not path.exists():
+        console.print("[red]文件不存在[/red]")
+        return
+
+    # 验证
+    console.print("[yellow]验证技能包...[/yellow]")
+    skill_info = validate_skill_package(str(path))
+    if not skill_info:
+        console.print("[red]无效的技能包，必须包含 SKILL.md[/red]")
+        return
+
+    # 选择安装位置
+    location = await select(
+        "选择安装位置:",
+        ["项目级 (当前工作目录)", "全局级 (用户目录)"],
+    )
+    if location is None:
+        return
+
+    if "项目级" in location:
+        install_path = session.workplace_path / ".chat" / "skills"
+    else:
+        install_path = Path.home() / ".chat" / "skills"
+
+    install_path.mkdir(parents=True, exist_ok=True)
+
+    console.print("[yellow]安装中...[/yellow]")
+    if install_skill(str(path), install_path):
+        name = skill_info["name"]
+        console.print(f"[green]技能 '{name}' 安装成功！[/green]")
+    else:
+        console.print("[red]安装失败[/red]")

chcode/utils/__init__.py

@@ -0,0 +1,3 @@
+from chcode.utils.text_utils import get_text_content
+
+__all__ = ["get_text_content"]

chcode/utils/enhanced_chat_openai.py

@@ -0,0 +1,368 @@
+"""
+Enhanced ChatOpenAI with support for third-party model reasoning content.
+
+This module extends langchain_openai's ChatOpenAI to support reasoning/thinking
+content from third-party models like Qwen, GLM, DeepSeek, etc.
+"""
+
+from __future__ import annotations
+
+from typing import Any, ClassVar
+
+from langchain_core.messages import AIMessage
+from langchain_core.outputs import ChatResult
+from langchain_openai import ChatOpenAI
+
+
+class EnhancedChatOpenAI(ChatOpenAI):
+    """Enhanced ChatOpenAI with third-party model reasoning support.
+
+    This class extends ChatOpenAI to support reasoning/thinking content
+    from third-party models (Qwen, GLM, DeepSeek, etc.) that use different
+    field names for reasoning output.
+
+    Supported reasoning fields:
+    - reasoning_content (Qwen)
+    - thinking (Generic)
+    - reasoning (DeepSeek)
+    - thought (GLM)
+    - thought_process (Custom)
+
+    Example:
+        ```python
+        from enhanced_chat_openai import EnhancedChatOpenAI
+
+        # For Qwen models
+        model = EnhancedChatOpenAI(
+            model="qwen-plus",
+            base_url="https://dashscope.aliyuncs.com/compatible-mode/v1",
+            api_key="your-api-key",
+            reasoning_field="reasoning_content"  # Qwen uses this field
+        )
+
+        response = model.invoke("What is 2+2?")
+
+        # Access reasoning content
+        reasoning = response.additional_kwargs.get("reasoning")
+        print(f"Reasoning: {reasoning}")
+
+    Note on streaming:
+        When using streaming mode, the reasoning content is accumulated across
+        all chunks and stored in the final message's additional_kwargs.
+        You can access it after the stream completes:
+
+        ```python
+        reasoning_parts = []
+        for chunk in model.stream(messages):
+            # Access reasoning from each chunk if needed
+            if "reasoning" in chunk.additional_kwargs:
+                reasoning_parts.append(chunk.additional_kwargs["reasoning"])
+
+        full_reasoning = "".join(reasoning_parts)
+        ```
+        print(f"Answer: {response.content}")
+        ```
+
+    Args:
+        reasoning_field: Field name for reasoning content in API response.
+            Options: "reasoning_content", "thinking", "reasoning", "thought",
+            "thought_process", or "auto" (auto-detect, default)
+        include_reasoning_in_content: Whether to prepend reasoning to content.
+            Default: False (reasoning stored only in additional_kwargs)
+        reasoning_separator: Separator between reasoning and content when included.
+            Default: "\n\n---\n\n"
+    """
+
+    reasoning_field: str = "auto"
+    include_reasoning_in_content: bool = False
+    reasoning_separator: str = "\n\n---\n\n"
+
+    # Known reasoning field mappings for different providers
+    REASONING_FIELDS: ClassVar[list[str]] = [
+        "reasoning_content",  # Qwen / Alibaba
+        "thinking",  # Generic / Anthropic-style
+        "reasoning",  # DeepSeek / OpenAI o1
+        "thought",  # GLM / Zhipu
+        "thought_process",  # Custom
+        "reasoning_text",  # Alternative
+        "thought_content",  # Alternative
+    ]
+
+    def _extract_reasoning(self, data: dict[str, Any]) -> str | None:
+        """Extract reasoning content from API response data.
+
+        Args:
+            data: Message dictionary from API response
+
+        Returns:
+            Reasoning content string or None if not found
+        """
+        # If specific field configured, try that first
+        if self.reasoning_field != "auto":
+            if self.reasoning_field in data:
+                return data[self.reasoning_field]
+            return None
+
+        # Auto-detect: try all known fields
+        for field in self.REASONING_FIELDS:
+            if field in data and data[field]:
+                return data[field]
+
+        return None
+
+    def _process_message_with_reasoning(
+        self, message: dict[str, Any]
+    ) -> dict[str, Any]:
+        """Process message to extract and format reasoning content.
+
+        Args:
+            message: Raw message dict from API
+
+        Returns:
+            Processed message dict
+        """
+        # Extract reasoning
+        reasoning = self._extract_reasoning(message)
+
+        if reasoning:
+            # Store in additional_kwargs
+            if "additional_kwargs" not in message:
+                message["additional_kwargs"] = {}
+            message["additional_kwargs"]["reasoning"] = reasoning
+
+            # Optionally include in content
+            if self.include_reasoning_in_content and message.get("content"):
+                message["content"] = (
+                    f"{reasoning}{self.reasoning_separator}{message['content']}"
+                )
+
+            # Remove original reasoning field from message
+            for field in self.REASONING_FIELDS:
+                if field in message:
+                    del message[field]
+
+        return message
+
+    def _extract_reasoning_from_message(self, message: Any) -> str | None:
+        """Extract reasoning content from message object.
+
+        Checks multiple sources:
+        1. reasoning_content field (Qwen style)
+        2. content_blocks with type='thinking'
+        3. reasoning field (DeepSeek style)
+        """
+        if message is None:
+            return None
+
+        reasoning_parts = []
+
+        # Method 1: Direct reasoning_content field
+        if hasattr(message, "reasoning_content") and message.reasoning_content:
+            if isinstance(message.reasoning_content, str):
+                reasoning_parts.append(message.reasoning_content)
+
+        # Method 2: content_blocks with thinking type
+        if hasattr(message, "content_blocks") and message.content_blocks:
+            for block in message.content_blocks:
+                # Handle both object and dict formats
+                block_type = None
+                thinking_content = None
+
+                if hasattr(block, "type"):
+                    block_type = block.type
+                elif isinstance(block, dict):
+                    block_type = block.get("type")
+
+                if block_type == "thinking":
+                    if hasattr(block, "thinking"):
+                        thinking_content = block.thinking
+                    elif isinstance(block, dict):
+                        thinking_content = block.get("thinking")
+
+                    if thinking_content and isinstance(thinking_content, str):
+                        reasoning_parts.append(thinking_content)
+
+        # Method 3: Check model_dump/dict for reasoning_content
+        if not reasoning_parts:
+            try:
+                if hasattr(message, "model_dump"):
+                    data = message.model_dump()
+                    if data.get("reasoning_content"):
+                        reasoning_parts.append(data["reasoning_content"])
+                elif hasattr(message, "dict"):
+                    data = message.dict()
+                    if data.get("reasoning_content"):
+                        reasoning_parts.append(data["reasoning_content"])
+            except Exception:
+                pass
+
+        # Combine all reasoning parts
+        if reasoning_parts:
+            return "\n".join(reasoning_parts)
+
+        return None
+
+    def _create_chat_result(
+        self, response: Any, generation_info: dict[str, Any] | None = None
+    ) -> ChatResult:
+        """Override to process reasoning content in response."""
+        # Extract reasoning from raw response before parent processing
+        reasoning_content = None
+        if hasattr(response, "choices") and response.choices:
+            try:
+                message = response.choices[0].message
+                reasoning_content = self._extract_reasoning_from_message(message)
+            except (AttributeError, IndexError):
+                pass
+
+        # Get result from parent
+        result = super()._create_chat_result(response, generation_info)
+
+        # Add reasoning to the message's additional_kwargs and content_blocks
+        if result.generations:
+            for generation in result.generations:
+                if isinstance(generation.message, AIMessage):
+                    # Add to additional_kwargs
+                    if reasoning_content:
+                        if "reasoning" not in generation.message.additional_kwargs:
+                            generation.message.additional_kwargs["reasoning"] = (
+                                reasoning_content
+                            )
+
+                    # Add to content_blocks if reasoning exists
+                    if reasoning_content:
+                        content_blocks = []
+
+                        # Add thinking block
+                        thinking_block = {
+                            "type": "thinking",
+                            "thinking": reasoning_content,
+                        }
+                        content_blocks.append(thinking_block)
+
+                        # Add text block with actual content
+                        if generation.message.content:
+                            text_block = {
+                                "type": "text",
+                                "text": generation.message.content,
+                            }
+                            content_blocks.append(text_block)
+
+                        # Store content_blocks in additional_kwargs
+                        generation.message.additional_kwargs["content_blocks"] = (
+                            content_blocks
+                        )
+
+                    break
+
+        return result
+
+    def _make_status_error_from_response(
+        self,
+        response: Any,
+        message: str,
+        *,
+        body: Any = None,
+    ) -> Exception:
+        """Override to handle reasoning in error responses."""
+        # Some providers include reasoning even in errors
+        if body and isinstance(body, dict):
+            if "choices" in body and body["choices"]:
+                for choice in body["choices"]:
+                    if "message" in choice:
+                        choice["message"] = self._process_message_with_reasoning(
+                            choice["message"]
+                        )
+
+        return super()._make_status_error_from_response(response, message, body=body)
+
+    def _convert_dict_to_message(self, _dict: dict[str, Any]) -> Any:
+        """Override to extract reasoning before conversion."""
+        # Process reasoning first
+        _dict = self._process_message_with_reasoning(_dict)
+
+        # Convert using parent method
+        return super()._convert_dict_to_message(_dict)
+
+    def _convert_chunk_to_generation_chunk(
+        self,
+        chunk: dict,
+        default_chunk_class: type,
+        base_generation_info: dict | None,
+    ):
+        """Override to extract reasoning_content from streaming chunks.
+
+        This is the correct method to override for streaming support.
+        The chunk here is already a dict from model_dump().
+        """
+        # First, let parent process the chunk
+        generation_chunk = super()._convert_chunk_to_generation_chunk(
+            chunk, default_chunk_class, base_generation_info
+        )
+
+        # Now extract reasoning_content if present
+        if generation_chunk is not None:
+            choices = chunk.get("choices", [])
+            if choices:
+                delta = choices[0].get("delta", {})
+                if delta and isinstance(delta, dict):
+                    reasoning_content = delta.get("reasoning_content")
+                    content = delta.get("content")
+
+                    # Ensure additional_kwargs exists
+                    if not hasattr(generation_chunk.message, "additional_kwargs"):
+                        generation_chunk.message.additional_kwargs = {}
+                    if generation_chunk.message.additional_kwargs is None:
+                        generation_chunk.message.additional_kwargs = {}
+
+                    # Accumulate reasoning
+                    if reasoning_content and isinstance(reasoning_content, str):
+                        if (
+                            "reasoning"
+                            not in generation_chunk.message.additional_kwargs
+                        ):
+                            generation_chunk.message.additional_kwargs["reasoning"] = ""
+                        generation_chunk.message.additional_kwargs["reasoning"] += (
+                            reasoning_content
+                        )
+
+                    # Build content_blocks for this chunk
+                    content_blocks = []
+
+                    # Add thinking block if we have reasoning in this chunk
+                    if reasoning_content and isinstance(reasoning_content, str):
+                        content_blocks.append(
+                            {
+                                "type": "thinking",
+                                "thinking": reasoning_content,
+                            }
+                        )
+
+                    # Add text block if we have content in this chunk
+                    if content and isinstance(content, str):
+                        content_blocks.append(
+                            {
+                                "type": "text",
+                                "text": content,
+                            }
+                        )
+
+                    # Store content_blocks if we have any
+                    if content_blocks:
+                        if (
+                            "content_blocks"
+                            not in generation_chunk.message.additional_kwargs
+                        ):
+                            generation_chunk.message.additional_kwargs[
+                                "content_blocks"
+                            ] = []
+                        generation_chunk.message.additional_kwargs[
+                            "content_blocks"
+                        ].extend(content_blocks)
+
+        return generation_chunk
+
+
+__all__ = [
+    "EnhancedChatOpenAI",
+]