chcode 0.1.0__py3-none-any.whl

chcode/__main__.py

@@ -0,0 +1,5 @@
+"""python -m chcode 入口"""
+from chcode.cli import app
+
+if __name__ == "__main__":
+    app()

chcode/agent_setup.py

@@ -0,0 +1,395 @@
+"""
+Agent 构建 — 中间件注册、checkpointer 初始化
+"""
+
+from __future__ import annotations
+
+import asyncio
+import sys
+from pathlib import Path
+from typing import Callable
+
+from langchain.agents import create_agent
+from langchain.agents.middleware import (
+    dynamic_prompt,
+    wrap_tool_call,
+    wrap_model_call,
+    ModelRequest,
+    ModelResponse,
+    HumanInTheLoopMiddleware,
+)
+from langchain.agents.middleware.context_editing import (
+    ContextEditingMiddleware,
+    ClearToolUsesEdit,
+)
+from langchain.agents.middleware.summarization import SummarizationMiddleware
+from langchain_core.messages import ToolMessage
+from langchain.tools.tool_node import ToolCallRequest
+from langgraph.types import Command
+from langgraph.checkpoint.sqlite.aio import AsyncSqliteSaver
+
+from chcode.utils.enhanced_chat_openai import EnhancedChatOpenAI
+from chcode.utils.modelscope_ratelimit import is_modelscope_model, get_modelscope_clients
+from chcode.utils.multimodal import is_multimodal_model
+from chcode.utils.skill_loader import SkillAgentContext
+from chcode.display import console
+from chcode.utils.tool_result_pipeline import (
+    clean_tool_output,
+    truncate_large_result,
+    enforce_per_turn_budget,
+    reset_budget_state,  # noqa: F401  # 重新导出供其他模块使用
+)
+
+import aiosqlite
+
+# ─── 内置默认模型配置 ──────────────────────────────────
+
+import os
+
+INNER_MODEL_CONFIG = {
+    "model": "Qwen/Qwen3-235B-A22B-Thinking-2507",
+    "base_url": "https://api-inference.modelscope.cn/v1",
+    "api_key": os.getenv("ModelScopeToken"),
+    "temperature": 1,
+    "top_p": 1,
+    "stream_usage": True,
+    "extra_body": {"stream": True},
+}
+
+
+# ─── 重试配置 ──────────────────────────────────────────
+
+RETRY_DELAYS = [3, 10, 30, 60]
+_fallback_models: list[dict] = []
+_fallback_index: int = 0
+
+
+def set_fallback_models(models: list[dict]) -> None:
+    global _fallback_models, _fallback_index
+    _fallback_models = models
+    _fallback_index = 0
+
+
+def get_fallback_model() -> dict | None:
+    if _fallback_index < len(_fallback_models):
+        return _fallback_models[_fallback_index]
+    return None
+
+
+def advance_fallback() -> None:
+    global _fallback_index
+    _fallback_index += 1
+
+
+def _load_fallback_config() -> dict | None:
+    """获取当前备用模型"""
+    global _fallback_models
+    if not _fallback_models:
+        from chcode.config import load_model_json
+
+        data = load_model_json()
+        fallback = data.get("fallback", {})
+        if not fallback:
+            return None
+        _fallback_models = list(fallback.values())
+
+    return get_fallback_model()
+
+
+# ─── 中间件 ──────────────────────────────────────────
+
+
+@wrap_tool_call
+async def handle_tool_errors(
+    request: ToolCallRequest, handler: Callable[[ToolCallRequest], Command]
+) -> Command | ToolMessage:
+    try:
+        return await handler(request)
+    except Exception as e:
+        return ToolMessage(
+            f"Tool error: Please check your input and try again ({e})",
+            tool_call_id=request.tool_call["id"],
+            status="error",
+        )
+
+
+class ModelSwitchError(Exception):
+    """标记需要切换模型的异常"""
+    pass
+
+
+@wrap_tool_call
+async def filter_vision_tool(
+    request: ToolCallRequest,
+    handler: Callable[[ToolCallRequest], Command],
+) -> Command | ToolMessage:
+    """多模态模型时屏蔽 vision 工具 — 模型自带视觉能力"""
+    tool_name = request.tool_call.get("name", "")
+    if tool_name == "vision":
+        model_config = request.runtime.context.model_config
+        model_name = model_config.get("model", "")
+
+        if is_multimodal_model(model_name):
+            return ToolMessage(
+                content="当前模型支持原生视觉，图片/视频已直接嵌入消息，无需调用 vision 工具。请直接分析消息中的图片/视频内容。",
+                tool_call_id=request.tool_call["id"],
+                status="error",
+            )
+    return await handler(request)
+
+
+@wrap_model_call
+async def model_retry_with_backoff(
+    request: ModelRequest, handler: Callable[[ModelRequest], ModelResponse]
+) -> ModelResponse:
+    """指数级退避重试中间件 — 每次调用独立计数"""
+    max_retries = 4
+
+    retry_count = 0
+
+    while True:
+        try:
+            return await handler(request)
+        except Exception as e:
+            retry_count += 1
+
+            if retry_count >= max_retries:
+                fallback = _load_fallback_config()
+                if fallback:
+                    console.print(f"[yellow]主模型重试{retry_count}次失败，切换到备用模型...[/yellow]")
+                    raise ModelSwitchError("切换到备用模型")
+                console.print(f"[red]请求失败，无备用模型可用，放弃请求\n  {e}[/red]")
+                raise
+
+            delay_idx = min(retry_count - 1, len(RETRY_DELAYS) - 1)
+            delay = RETRY_DELAYS[delay_idx]
+
+            console.print(f"[yellow]请求失败 ({retry_count}/{max_retries}), {delay}秒后重试...\n  {e}[/yellow]")
+
+            await asyncio.sleep(delay)
+
+
+@dynamic_prompt
+async def load_skills(request: ModelRequest) -> str:
+    """构建 system prompt — Level 1: 注入所有 Skills 元数据"""
+    skill_loader = request.runtime.context.skill_loader
+    os_name = sys.platform
+    model_config = request.runtime.context.model_config
+    model_name = model_config.get("model", "")
+
+    native_vision = is_multimodal_model(model_name)
+
+    if native_vision:
+        base_prompt = f"""You are a coding assistant. OS: {os_name}. CWD: {request.runtime.context.working_directory}.
+
+Tools:
+- bash: execute shell commands and scripts. Stop immediately if the user refuses.
+- read_file: view file content; write_file: create or save files; edit: modify existing files. Always read before write, prefer edit over write_file.
+- glob: find files by name pattern; grep: search file contents with regex; list_dir: browse directory structure.
+- web_search: search the Internet; web_fetch: fetch and read a URL's content.
+- ask_user: present choices to the user and collect their input or confirmation.
+- todo_write: create and manage a task list for complex multi-step work.
+- load_skill: when a request matches a skill's description, load it first to get detailed instructions.
+
+ Guidelines:
+- Never create .md/README files unless explicitly asked.
+- You have native vision capability. When the user sends an image or video file path, the image/video is already embedded in the message — analyze it directly. Do NOT call the vision tool."""
+    else:
+        base_prompt = f"""You are a coding assistant. OS: {os_name}. CWD: {request.runtime.context.working_directory}.
+
+Tools:
+- bash: execute shell commands and scripts. Stop immediately if the user refuses.
+- read_file: view file content; write_file: create or save files; edit: modify existing files. Always read before write, prefer edit over write_file.
+- glob: find files by name pattern; grep: search file contents with regex; list_dir: browse directory structure.
+- web_search: search the Internet; web_fetch: fetch and read a URL's content.
+- ask_user: present choices to the user and collect their input or confirmation.
+- todo_write: create and manage a task list for complex multi-step work.
+- load_skill: when a request matches a skill's description, load it first to get detailed instructions.
+- vision: analyze an image or video file using a vision model. Use when the user provides an image/video path or asks about visual content. Supports PNG, JPG, GIF, BMP, WebP, TIFF, MP4, MOV, AVI, MKV, WebM. The user can paste file paths directly in chat.
+
+ Guidelines:
+- Never create .md/README files unless explicitly asked.
+- When the user sends an image or video file path, use vision to understand it before responding."""
+
+    return await asyncio.to_thread(skill_loader.build_system_prompt, base_prompt)
+
+
+@wrap_model_call
+async def load_model(
+    request: ModelRequest, handler: Callable[[ModelRequest], ModelResponse]
+) -> ModelResponse:
+    """动态加载模型"""
+    model_config = request.runtime.context.model_config
+    kwargs = dict(model_config)
+    if is_modelscope_model(model_config):
+        sync_client, async_client = get_modelscope_clients()
+        kwargs["http_client"] = sync_client
+        kwargs["http_async_client"] = async_client
+    return await handler(request.override(model=EnhancedChatOpenAI(**kwargs)))
+
+
+@wrap_model_call
+async def fix_messages(
+    request: ModelRequest, handler: Callable[[ModelRequest], ModelResponse]
+) -> ModelResponse:
+    """过滤隐藏消息"""
+    messages = request.messages
+    real_messages = [m for m in messages if not m.additional_kwargs.get("composed", "")]
+    if len(real_messages) == len(messages):
+        return await handler(request)
+    return await handler(request.override(messages=real_messages))
+
+
+@wrap_model_call
+async def tool_result_budget(
+    request: ModelRequest, handler: Callable[[ModelRequest], ModelResponse]
+) -> ModelResponse:
+    """工具结果截断和 token 预算控制"""
+    workplace = request.runtime.context.working_directory
+    messages = list(request.messages)
+    changed = False
+    for i, msg in enumerate(messages):
+        if isinstance(msg, ToolMessage) and msg.content:
+            if msg.additional_kwargs.get("_budget_ok"):
+                continue
+            cleaned = clean_tool_output(msg.content)
+            truncated = truncate_large_result(
+                cleaned,
+                msg.name or "",
+                msg.tool_call_id,
+                workplace=workplace,
+            )
+            new_kwargs = {**msg.additional_kwargs, "_budget_ok": True}
+            messages[i] = msg.model_copy(update={"content": truncated, "additional_kwargs": new_kwargs})
+            changed = True
+    if changed:
+        messages = enforce_per_turn_budget(messages, budget=200_000, workplace=workplace)
+        return await handler(request.override(messages=messages))
+    return await handler(request)
+
+
+# ─── Agent 构建 ──────────────────────────────────────────
+
+
+class AsyncHITL(HumanInTheLoopMiddleware):
+    """异步 HITL 中间件 — 审批在 chat loop 中处理"""
+
+    async def awrap_model_call(self, request, handler):
+        return await handler(request)
+
+
+_hitl_middleware: AsyncHITL | None = None
+_summarization_model: EnhancedChatOpenAI | None = None
+
+
+def _build_interrupt_on(yolo: bool) -> dict:
+    return (
+        {}
+        if yolo
+        else {
+            "bash": {"allowed_decisions": ["approve", "reject"]},
+            "edit": {"allowed_decisions": ["approve", "reject"]},
+            "write_file": {"allowed_decisions": ["approve", "reject"]},
+        }
+    )
+
+
+def _dummy_model():
+    from langchain_openai import ChatOpenAI
+
+    return ChatOpenAI(model="placeholder", api_key="sk-placeholder", max_retries=0)
+
+
+def build_agent(
+    model_config: dict | None = None,
+    checkpointer: AsyncSqliteSaver | None = None,
+    mcp_tools: list | None = None,
+    yolo: bool = False,
+) -> object:
+    """构建 agent 实例"""
+    global _hitl_middleware, _summarization_model
+
+    cfg = model_config or INNER_MODEL_CONFIG
+    model = _dummy_model()
+
+    _hitl_middleware = AsyncHITL(interrupt_on=_build_interrupt_on(yolo))
+    _summarization_model = EnhancedChatOpenAI(**cfg)
+
+    # 加载 fallback 模型配置
+    from chcode.config import load_model_json, get_context_window_size
+
+    data = load_model_json()
+    fallback = data.get("fallback", {})
+    if fallback:
+        current_model = cfg.get("model", "")
+        filtered = [v for k, v in fallback.items() if v.get("model") != current_model]
+        set_fallback_models(filtered)
+
+    # 摘要触发阈值 = 上下文窗口的 90%
+    model_name = cfg.get("model", "")
+    ctx_window = get_context_window_size(model_name)
+    summary_trigger = int(ctx_window * 0.9)
+
+    agent = create_agent(
+        model,
+        _get_all_tools() + (mcp_tools or []),
+        middleware=[
+            handle_tool_errors,
+            filter_vision_tool,
+            tool_result_budget,
+            load_skills,
+            load_model,
+            model_retry_with_backoff,
+            fix_messages,
+            ContextEditingMiddleware(
+                edits=[
+                    ClearToolUsesEdit(
+                        trigger=100_000,
+                        keep=3,
+                        exclude_tools=["read_file"],
+                        placeholder="[Old tool result content cleared]",
+                    )
+                ]
+            ),
+            SummarizationMiddleware(
+                model=_summarization_model,
+                trigger=("tokens", summary_trigger),
+                keep=("messages", 20),
+            ),
+            _hitl_middleware,
+        ],
+        context_schema=SkillAgentContext,
+        checkpointer=checkpointer,
+    )
+    return agent
+
+
+def update_hitl_config(yolo: bool) -> None:
+    """运行时更新 HITL interrupt_on 配置，无需重建 agent"""
+    if _hitl_middleware is not None:
+        _hitl_middleware.interrupt_on = _build_interrupt_on(yolo)
+
+
+def update_summarization_model(model_config: dict) -> None:
+    """运行时更新 SummarizationMiddleware 的模型"""
+    if _summarization_model is not None:
+        new_model = EnhancedChatOpenAI(**model_config)
+        for key in new_model.model_fields_set:
+            try:
+                if key in new_model.__dict__:
+                    setattr(_summarization_model, key, new_model.__dict__[key])
+            except (AttributeError, TypeError):
+                pass
+
+
+async def create_checkpointer(db_path: Path) -> AsyncSqliteSaver:
+    """创建异步 SQLite checkpointer"""
+    conn = await aiosqlite.connect(str(db_path))
+    return AsyncSqliteSaver(conn)
+
+
+def _get_all_tools() -> list:
+    """获取所有工具（延迟导入避免循环依赖）"""
+    from chcode.utils.tools import ALL_TOOLS
+
+    return ALL_TOOLS

chcode/agents/definitions.py

@@ -0,0 +1,158 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+
+
+@dataclass
+class AgentDefinition:
+    agent_type: str
+    when_to_use: str
+    system_prompt: str
+    tools: list[str] | None = None
+    disallowed_tools: list[str] = field(default_factory=list)
+    model: str | None = None
+    read_only: bool = False
+    source: str = "built-in"
+
+
+_GENERAL_PURPOSE_SYSTEM_PROMPT = """You are a sub-agent for ChCode, a terminal-based AI coding assistant. Given the task description, use the tools available to complete it fully.
+
+Your strengths:
+- Searching for code, configurations, and patterns across large codebases
+- Analyzing multiple files to understand system architecture
+- Investigating complex questions that require exploring many files
+- Performing multi-step research tasks
+
+Guidelines:
+- For file searches: search broadly when you don't know where something lives. Use read_file when you know the specific file path.
+- For analysis: Start broad and narrow down. Use multiple search strategies if the first doesn't yield results.
+- Be thorough: Check multiple locations, consider different naming conventions, look for related files.
+- NEVER create files unless they're absolutely necessary for achieving your goal. ALWAYS prefer editing an existing file to creating a new one.
+- NEVER proactively create documentation files (*.md) or README files. Only create documentation files if explicitly requested.
+
+When you complete the task, respond with a concise report covering what was done and any key findings."""
+
+
+_EXPLORE_SYSTEM_PROMPT = """You are a file search specialist for ChCode. You excel at thoroughly navigating and exploring codebases.
+
+=== CRITICAL: READ-ONLY MODE - NO FILE MODIFICATIONS ===
+This is a READ-ONLY exploration task. You are STRICTLY PROHIBITED from:
+- Creating new files (no write_file, touch, or file creation of any kind)
+- Modifying existing files (no edit operations)
+- Deleting files (no rm or deletion)
+- Moving or copying files (no mv or cp)
+- Running ANY commands that change system state
+
+Your role is EXCLUSIVELY to search and analyze existing code.
+
+Your strengths:
+- Rapidly finding files using glob patterns
+- Searching code and text with powerful regex patterns via grep
+- Reading and analyzing file contents
+
+Guidelines:
+- Use glob for broad file pattern matching
+- Use grep for searching file contents with regex
+- Use read_file when you know the specific file path you need to read
+- Use bash ONLY for read-only operations (ls, git status, git log, git diff, find, cat, head, tail)
+- NEVER use bash for: mkdir, touch, rm, cp, mv, git add, git commit, npm install, pip install, or any file creation/modification
+- Adapt your search approach based on the thoroughness level specified by the caller
+- Communicate your final report directly as a regular message - do NOT attempt to create files
+
+NOTE: You are meant to be a fast agent that returns output as quickly as possible. In order to achieve this you must:
+- Make efficient use of the tools that you have at your disposal: be smart about how you search for files and implementations
+- Wherever possible you should try to spawn multiple parallel tool calls for grepping and reading files
+
+Complete the user's search request efficiently and report your findings clearly."""
+
+
+_PLAN_SYSTEM_PROMPT = """You are a software architect and planning specialist for ChCode. Your role is to explore the codebase and design implementation plans.
+
+=== CRITICAL: READ-ONLY MODE - NO FILE MODIFICATIONS ===
+This is a READ-ONLY planning task. You are STRICTLY PROHIBITED from:
+- Creating new files (no write_file, touch, or file creation of any kind)
+- Modifying existing files (no edit operations)
+- Deleting files (no rm or deletion)
+- Running ANY commands that change system state
+
+Your role is EXCLUSIVELY to explore the codebase and design implementation plans.
+
+You will be provided with a set of requirements and optionally a perspective on how to approach the design process.
+
+## Your Process
+
+1. **Understand Requirements**: Focus on the requirements provided and apply your assigned perspective throughout the design process.
+
+2. **Explore Thoroughly**:
+   - Read any files provided to you in the initial prompt
+   - Find existing patterns and conventions using glob, grep, and read_file
+   - Understand the current architecture
+   - Identify similar features as reference
+   - Trace through relevant code paths
+   - Use bash ONLY for read-only operations (ls, git status, git log, git diff, find, cat, head, tail)
+   - NEVER use bash for: mkdir, touch, rm, cp, mv, git add, git commit, npm install, pip install, or any file creation/modification
+
+3. **Design Solution**:
+   - Create implementation approach based on your assigned perspective
+   - Consider trade-offs and architectural decisions
+   - Follow existing patterns where appropriate
+
+4. **Detail the Plan**:
+   - Provide step-by-step implementation strategy
+   - Identify dependencies and sequencing
+   - Anticipate potential challenges
+
+## Required Output
+
+End your response with:
+
+### Critical Files for Implementation
+List 3-5 files most critical for implementing this plan:
+- path/to/file1
+- path/to/file2
+- path/to/file3
+
+REMEMBER: You can ONLY explore and plan. You CANNOT and MUST NOT write, edit, or modify any files."""
+
+
+BUILT_IN_AGENTS: dict[str, AgentDefinition] = {
+    "general-purpose": AgentDefinition(
+        agent_type="general-purpose",
+        when_to_use=(
+            "General-purpose agent for researching complex questions, searching for code, "
+            "and executing multi-step tasks. When you are searching for a keyword or file "
+            "and are not confident that you will find the right match in the first few tries "
+            "use this agent to perform the search for you."
+        ),
+        system_prompt=_GENERAL_PURPOSE_SYSTEM_PROMPT,
+        tools=None,
+        disallowed_tools=[],
+        read_only=False,
+    ),
+    "Explore": AgentDefinition(
+        agent_type="Explore",
+        when_to_use=(
+            "Fast agent specialized for exploring codebases. Use this when you need to quickly find files by patterns "
+            '(eg. "src/components/**/*.tsx"), search code for keywords (eg. "API endpoints"), or answer questions '
+            'about the codebase (eg. "how do API endpoints work?"). When calling this agent, specify the desired '
+            'thoroughness level: "quick" for basic searches, "medium" for moderate exploration, or '
+            '"very thorough" for comprehensive analysis across multiple locations and naming conventions.'
+        ),
+        system_prompt=_EXPLORE_SYSTEM_PROMPT,
+        tools=None,
+        disallowed_tools=["write_file", "edit"],
+        read_only=True,
+    ),
+    "Plan": AgentDefinition(
+        agent_type="Plan",
+        when_to_use=(
+            "Software architect agent for designing implementation plans. Use this when you need to "
+            "plan the implementation strategy for a task. Returns step-by-step plans, identifies "
+            "critical files, and considers architectural trade-offs."
+        ),
+        system_prompt=_PLAN_SYSTEM_PROMPT,
+        tools=None,
+        disallowed_tools=["write_file", "edit"],
+        read_only=True,
+    ),
+}

chcode/agents/loader.py

@@ -0,0 +1,104 @@
+from __future__ import annotations
+
+import re
+from pathlib import Path
+
+import yaml
+
+from chcode.agents.definitions import AgentDefinition
+
+DEFAULT_AGENT_PATHS = [
+    Path.cwd() / ".chat" / "agents",
+    Path.home() / ".chat" / "agents",
+]
+
+
+def _parse_agent_md(md_path: Path) -> AgentDefinition | None:
+    try:
+        content = md_path.read_text(encoding="utf-8")
+    except Exception:
+        return None
+
+    fm_match = re.match(r"^---\s*\n(.*?)\n---\s*\n", content, re.DOTALL)
+    if not fm_match:
+        return None
+
+    try:
+        frontmatter = yaml.safe_load(fm_match.group(1))
+    except yaml.YAMLError:
+        return None
+
+    if not isinstance(frontmatter, dict):
+        return None
+
+    agent_type = frontmatter.get("name", "")
+    description = frontmatter.get("description", "")
+
+    if not agent_type or not description:
+        return None
+
+    body = content[fm_match.end() :]
+    system_prompt = body.strip()
+    if not system_prompt:
+        return None
+
+    tools_raw = frontmatter.get("tools")
+    tools = (
+        [t.strip() for t in tools_raw.split(",") if t.strip()]
+        if isinstance(tools_raw, str)
+        else None
+    )
+
+    disallowed_raw = frontmatter.get("disallowed_tools")
+    disallowed_tools = (
+        [t.strip() for t in disallowed_raw.split(",") if t.strip()]
+        if isinstance(disallowed_raw, str)
+        else []
+    )
+
+    model = frontmatter.get("model") or None
+    read_only = bool(frontmatter.get("read_only", False))
+
+    return AgentDefinition(
+        agent_type=agent_type,
+        when_to_use=description.replace("\\n", "\n"),
+        system_prompt=system_prompt,
+        tools=tools,
+        disallowed_tools=disallowed_tools,
+        model=model,
+        read_only=read_only,
+        source="custom",
+    )
+
+
+_agents_cache: dict[str, AgentDefinition] | None = None
+
+
+def load_agents(extra_paths: list[Path] | None = None) -> dict[str, AgentDefinition]:
+    global _agents_cache
+
+    if _agents_cache is not None and not extra_paths:
+        return dict(_agents_cache)
+
+    from chcode.agents.definitions import BUILT_IN_AGENTS
+
+    result: dict[str, AgentDefinition] = dict(BUILT_IN_AGENTS)
+
+    paths = list(DEFAULT_AGENT_PATHS)
+    if extra_paths:
+        paths = extra_paths + paths
+
+    for base_path in paths:
+        if not base_path.exists():
+            continue
+        for item in base_path.iterdir():
+            if not item.is_file() or not item.suffix == ".md":
+                continue
+            agent = _parse_agent_md(item)
+            if agent and agent.agent_type not in result:
+                result[agent.agent_type] = agent
+
+    if not extra_paths:
+        _agents_cache = result
+
+    return result