chcode 0.1.0__py3-none-any.whl

chcode/utils/git_checker.py

@@ -0,0 +1,38 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Git可用性检查工具
+用于判断系统中Git是否可用
+"""
+import subprocess
+from typing import Tuple, Optional
+
+
+def check_git_availability() -> Tuple[bool, str, Optional[str]]:
+    """
+    检查Git是否可用
+
+    Returns:
+        Tuple[bool, str, Optional[str]]: (是否可用, 状态描述, Git版本信息)
+    """
+    try:
+        result = subprocess.run(
+            ["git", "--version"],
+            capture_output=True,
+            text=True,
+            timeout=10,
+        )
+
+        if result.returncode == 0:
+            version_info = result.stdout.strip()
+            return True, "Git可用", version_info
+        else:
+            error_msg = result.stderr.strip() if result.stderr else "未知错误"
+            return False, f"Git命令执行失败: {error_msg}", None
+
+    except FileNotFoundError:
+        return False, "未找到Git命令，请确保Git已安装并添加到PATH环境变量中", None
+    except subprocess.TimeoutExpired:
+        return False, "Git命令执行超时", None
+    except Exception as e:
+        return False, f"检查Git时发生异常: {str(e)}", None

chcode/utils/git_manager.py

@@ -0,0 +1,261 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+import subprocess
+from pathlib import Path
+from typing import Optional
+import json
+
+
+class GitManager:
+    """增强版Git检查点管理器，支持.gitignore管理"""
+
+    MINIMAL_GITIGNORE = ".git\n.chat\n.venv\n.gitignore\n__pycache__\n*.pyc\n.pytest_cache\n.coverage\n.pytest_cache/\n"
+
+    def __init__(self, repo_path: str = "."):
+        self.repo_path = Path(repo_path).resolve()
+        self.git_cmd = "git"
+        self.checkpoints_file = self.repo_path / ".git" / "checkpoints.json"
+        self.gitignore_file = self.repo_path / ".gitignore"
+        self.current_id = 0
+        self._is_repo: bool | None = None
+
+    def _run(
+        self, args: list, timeout: int = 30, silent: bool = True
+    ) -> subprocess.CompletedProcess:
+        """执行Git命令
+
+        Args:
+            args: Git 命令参数
+            timeout: 超时时间（秒）
+            silent: 是否静默输出（默认 True，不打印调试信息）
+        """
+        try:
+            result = subprocess.run(
+                [self.git_cmd] + args,
+                cwd=str(self.repo_path),
+                capture_output=True,
+                text=True,
+                encoding="utf-8",
+                timeout=timeout,
+            )
+
+            if result.returncode != 0 and not silent:
+                print(f"Git命令返回码: {result.returncode}")
+                if result.stderr:
+                    print(f" STDERR: {result.stderr.strip()}")
+                if result.stdout:
+                    print(f" STDOUT: {result.stdout.strip()}")
+
+            return result
+        except subprocess.TimeoutExpired:
+            raise RuntimeError(f"Git命令超时（{timeout}秒）: git {' '.join(args)}")
+        except Exception as e:
+            raise RuntimeError(f"Git命令执行失败: {e}")
+
+    def is_repo(self) -> bool:
+        """检查是否为Git仓库"""
+        if self._is_repo is not None:
+            return self._is_repo
+        try:
+            self._is_repo = self._run(["rev-parse", "--git-dir"]).returncode == 0
+            return self._is_repo
+        except Exception:
+            return False
+
+    def init(self) -> bool:
+        """初始化Git仓库"""
+        if self.is_repo():
+            if not self.checkpoints_file.exists():
+                self.checkpoints_file.write_text(
+                    json.dumps({}, indent=4), encoding="utf-8"
+                )
+            self._ensure_init_checkpoint()
+            return False
+        if not self.gitignore_file.exists():
+            self.create_gitignore()
+        result = self._run(["init"])
+        if result.returncode == 0:
+            # 初始空提交，确保后续 commit 不会因空仓库失败
+            self._run(["commit", "-m", "init", "--allow-empty"])
+        self._ensure_init_checkpoint()
+        return result.returncode == 0
+
+    def _ensure_init_checkpoint(self) -> None:
+        """确保 checkpoints.json 中存在 "init" 条目，供 rollback 使用"""
+        if not self.checkpoints_file.exists():
+            self.checkpoints_file.write_text(
+                json.dumps({}, indent=4), encoding="utf-8"
+            )
+        data = json.loads(self.checkpoints_file.read_text(encoding="utf-8"))
+        if "init" in data:
+            return
+        hash_result = self._run(["rev-list", "--max-parents=0", "HEAD"])
+        if hash_result.returncode == 0 and hash_result.stdout.strip():
+            data["init"] = hash_result.stdout.strip().split("\n")[-1]
+            self.checkpoints_file.write_text(
+                json.dumps(data, indent=4), encoding="utf-8"
+            )
+
+    def add_commit(self, message_ids: str, files: list | None = None) -> bool | int:
+        """添加文件并提交"""
+        if files is None:
+            files = ["."]
+        if self._run(["add"] + files).returncode != 0:
+            return False
+
+        # 提交
+        commit_msg = f"{message_ids} (CP#{self.current_id + 1})"
+        commit_result = self._run(["commit", "-m", commit_msg])
+
+        if commit_result.returncode == 0:
+            # 获取提交ID
+            hash_result = self._run(["rev-parse", "HEAD"])
+            if hash_result.returncode == 0:
+                commit_id = hash_result.stdout.strip()
+
+                checkpoint_dict = {}
+                checkpoint_dict[message_ids] = commit_id
+                if self.checkpoints_file.exists():
+                    checkpoint_dict.update(
+                        json.loads(self.checkpoints_file.read_text(encoding="utf-8"))
+                    )
+                count = len(checkpoint_dict)
+                self.checkpoints_file.write_text(
+                    json.dumps(checkpoint_dict, indent=4), encoding="utf-8"
+                )
+
+                self.current_id += 1
+                return count
+        return False
+
+    def rollback(self, message_ids: list[str], all_ids: list[str]) -> bool | int:
+        """回滚到指定检查点
+        第一步：检查是否存在精确匹配（存在于JSON中有对应提交的ID），如果有则直接回溯到其上一次提交
+        第二步：如果没有精确匹配，才进入模糊匹配逻辑，按以下三种情况进行处理：
+        前有提交后有提交：直接回溯到前面最近的提交
+        前无提交：回溯到初始提交
+        前有提交后无提交：不回溯，返回当前计数
+        """
+        if not self.checkpoints_file.exists():
+            return False
+
+        json_data = self.checkpoints_file.read_text(encoding="utf-8")
+        checkpointer_dict: dict = json.loads(json_data)
+
+        message_ids_str = "&".join(message_ids)
+
+        # -- 辅助：根据 all_ids 位置将非 init 的 checkpoint 分为 before / at_or_after --
+        def _classify_checkpoint_keys():
+            before = []
+            at_or_after = []
+            fork_id = message_ids[0]
+            fork_index = all_ids.index(fork_id) if fork_id in all_ids else -1
+
+            for k in list(checkpointer_dict.keys()):
+                if k == "init":
+                    continue
+                first_msg_id = k.split("&")[0]
+                if first_msg_id not in all_ids:
+                    continue
+                idx = all_ids.index(first_msg_id)
+                if idx < fork_index:
+                    before.append((idx, k))
+                else:
+                    at_or_after.append(k)
+
+            before.sort(key=lambda x: x[0])
+            return before, at_or_after
+
+        # -- 第一步：精确匹配 --
+        if message_ids_str in checkpointer_dict:
+            aim_id = checkpointer_dict[message_ids_str] + "~1"
+
+            _, keys_to_remove = _classify_checkpoint_keys()
+            keys_to_remove_set = set(keys_to_remove)
+            keys_to_remove_set.add(message_ids_str)
+
+            for k in keys_to_remove_set:
+                checkpointer_dict.pop(k, None)
+
+            count = len(checkpointer_dict)
+
+            try:
+                reset_result = self._run(["reset", "--hard", aim_id])
+                if reset_result.returncode == 0:
+                    self.checkpoints_file.write_text(
+                        json.dumps(checkpointer_dict, indent=4), encoding="utf-8"
+                    )
+                    return count
+                else:
+                    return False
+            except Exception:
+                return False
+
+        # -- 第二步：模糊匹配 --
+        before_keys, at_or_after_keys = _classify_checkpoint_keys()
+
+        has_before = len(before_keys) > 0
+        has_after = len(at_or_after_keys) > 0
+
+        if has_before and has_after:
+            # Case 1：前有提交后有提交 -> 回溯到前面最近的提交（保留该提交本身的状态）
+            latest_before_key = before_keys[-1][1]
+            aim_id = checkpointer_dict[latest_before_key]
+
+            for k in at_or_after_keys:
+                checkpointer_dict.pop(k)
+
+        elif not has_before and has_after:
+            # Case 2：前无提交后有提交 -> 回溯到初始提交
+            aim_id = checkpointer_dict["init"]
+
+            for k in at_or_after_keys:
+                checkpointer_dict.pop(k)
+
+        elif has_before and not has_after:
+            # Case 3：前有提交后无提交 -> 不回溯
+            count = len(checkpointer_dict)
+            return count
+        else:
+            count = len(checkpointer_dict)
+            return count
+
+        count = len(checkpointer_dict)
+
+        try:
+            reset_result = self._run(["reset", "--hard", aim_id])
+            if reset_result.returncode == 0:
+                self.checkpoints_file.write_text(
+                    json.dumps(checkpointer_dict, indent=4), encoding="utf-8"
+                )
+                return count
+            else:
+                return False
+        except Exception:
+            return False
+
+    def count_checkpoints(self, count: int | None = None) -> int:
+        """统计检查点数量"""
+        if count is None:
+            if not self.checkpoints_file.exists():
+                return 0
+            json_data = self.checkpoints_file.read_text(encoding="utf-8")
+            checkpointer_dict = json.loads(json_data)
+            return len(checkpointer_dict)
+        else:
+            return count
+
+    def create_gitignore(self, content: Optional[str] = None) -> bool:
+        """创建.gitignore文件，屏蔽.git和.venv等"""
+        try:
+            if content is None:
+                content = self.MINIMAL_GITIGNORE
+
+            with open(self.gitignore_file, "w", encoding="utf-8") as f:
+                f.write(content)
+
+            self._run(["add", ".gitignore"])
+            return True
+        except Exception as e:
+            print(f"创建.gitignore失败: {e}")
+            return False

chcode/utils/modelscope_ratelimit.py

@@ -0,0 +1,65 @@
+"""ModelScope API 调用次数监控（解耦模块）
+
+通过自定义 httpx Transport 捕获响应头中的 ratelimit 信息，
+供状态栏实时显示。仅在 base_url 包含 modelscope 时启用。
+"""
+
+from __future__ import annotations
+
+import httpx
+import threading
+
+_ratelimit_data: dict = {}
+_ratelimit_lock = threading.Lock()
+
+_cached_sync: httpx.Client | None = None
+_cached_async: httpx.AsyncClient | None = None
+_client_lock = threading.Lock()
+
+
+def get_ratelimit() -> dict:
+    with _ratelimit_lock:
+        return dict(_ratelimit_data) if _ratelimit_data else {}
+
+
+def is_modelscope_model(model_config: dict) -> bool:
+    return "modelscope" in model_config.get("base_url", "").lower()
+
+
+def _update_ratelimit(headers: httpx.Headers) -> None:
+    total_limit = headers.get("modelscope-ratelimit-requests-limit")
+    if not total_limit:
+        return
+    try:
+        with _ratelimit_lock:
+            _ratelimit_data.update({
+                "total_limit": int(total_limit),
+                "total_remaining": int(headers.get("modelscope-ratelimit-requests-remaining", 0)),
+                "model_limit": int(headers.get("modelscope-ratelimit-model-requests-limit", 0)),
+                "model_remaining": int(headers.get("modelscope-ratelimit-model-requests-remaining", 0)),
+            })
+    except (ValueError, TypeError):
+        pass
+
+
+class _HeaderCaptureTransport(httpx.HTTPTransport):
+    def handle_request(self, request):
+        response = super().handle_request(request)
+        _update_ratelimit(response.headers)
+        return response
+
+
+class _HeaderCaptureAsyncTransport(httpx.AsyncHTTPTransport):
+    async def handle_async_request(self, request):
+        response = await super().handle_async_request(request)
+        _update_ratelimit(response.headers)
+        return response
+
+
+def get_modelscope_clients() -> tuple[httpx.Client, httpx.AsyncClient]:
+    global _cached_sync, _cached_async
+    with _client_lock:
+        if _cached_sync is None or _cached_async is None:
+            _cached_sync = httpx.Client(transport=_HeaderCaptureTransport())
+            _cached_async = httpx.AsyncClient(transport=_HeaderCaptureAsyncTransport())
+        return _cached_sync, _cached_async

chcode/utils/multimodal.py

@@ -0,0 +1,268 @@
+"""
+Multimodal model detection and media encoding utilities.
+
+Provides:
+- is_multimodal_model(): Check if a model name indicates native vision capability
+- encode_media_as_base64(): Read and base64-encode an image or video
+- extract_media_paths(): Detect image/video file paths in user text
+- build_multimodal_message(): Construct a HumanMessage with embedded media
+"""
+
+from __future__ import annotations
+
+import base64
+import io
+import re
+from pathlib import Path
+
+from langchain_core.messages import HumanMessage
+
+# ─── Multimodal model patterns ──────────────────────────────────
+
+# Models whose short name (after /) or full name matches these patterns
+# are considered multimodal (native vision capability).
+MULTIMODAL_MODEL_PATTERNS: list[str] = [
+    # Kimi K2.5 series
+    "Kimi-K2",
+    # Qwen3 VL (dedicated vision-language)
+    "Qwen3-VL",
+    # Qwen3.5 MoE models with vision
+    "Qwen3.5-397B",
+    "Qwen3.5-122B",
+    "Qwen3.5-35B",
+    "Qwen3.5-27B",
+    # Intern-S1 series
+    "Intern-S1",
+]
+
+
+def is_multimodal_model(model_name: str) -> bool:
+    """Check if a model name indicates native multimodal (vision) capability.
+
+    Handles both short names (e.g., "Kimi-K2.5") and full names
+    (e.g., "moonshotai/Kimi-K2.5"). Case-insensitive.
+    """
+    if not model_name:
+        return False
+    short_name = model_name.split("/")[-1]
+    lower_name = model_name.lower()
+    lower_short = short_name.lower()
+    for pattern in MULTIMODAL_MODEL_PATTERNS:
+        lower_pattern = pattern.lower()
+        if lower_pattern in lower_short or lower_pattern in lower_name:
+            return True
+    return False
+
+
+# ─── Supported formats ─────────────────────────────────────────
+
+_IMAGE_EXTS = frozenset({
+    ".png", ".jpg", ".jpeg", ".gif", ".bmp", ".webp", ".tiff", ".tif",
+})
+
+_VIDEO_EXTS = frozenset({
+    ".mp4", ".mov", ".avi", ".mkv", ".webm",
+})
+
+_ALL_MEDIA_EXTS = _IMAGE_EXTS | _VIDEO_EXTS
+
+_VIDEO_EXT_NAMES = frozenset(e.lstrip(".") for e in _VIDEO_EXTS)
+
+_MIME_MAP: dict[str, str] = {
+    "jpg": "image/jpeg",
+    "jpeg": "image/jpeg",
+    "png": "image/png",
+    "gif": "image/gif",
+    "bmp": "image/bmp",
+    "webp": "image/webp",
+    "tiff": "image/tiff",
+    "tif": "image/tiff",
+    "mp4": "video/mp4",
+    "mov": "video/quicktime",
+    "avi": "video/x-msvideo",
+    "mkv": "video/x-matroska",
+    "webm": "video/webm",
+}
+
+# ─── Media encoding ────────────────────────────────────────────
+
+
+def encode_media_as_base64(
+    path: Path,
+    max_side: int = 2048,
+) -> tuple[str, str]:
+    """Read an image or video, return (base64_data, mime_type).
+
+    For images larger than max_side pixels, the image is resized
+    before encoding. Videos are encoded without modification.
+
+    Raises:
+        FileNotFoundError: If the file does not exist.
+        ValueError: If the file is not valid or too large.
+        IOError: If the image cannot be read/decoded.
+    """
+    if not path.exists():
+        raise FileNotFoundError(f"File not found: {path}")
+    if not path.is_file():
+        raise ValueError(f"Not a file: {path}")
+
+    ext = path.suffix.lower().lstrip(".")
+    if ext not in _MIME_MAP:
+        raise ValueError(f"Unsupported media format: {path.suffix}")
+
+    mime_type = _MIME_MAP.get(ext, "application/octet-stream")
+
+    is_video = ext in _VIDEO_EXT_NAMES
+
+    if is_video:
+        file_size = path.stat().st_size
+        if file_size > 14.9 * 1024 * 1024:
+            raise ValueError(
+                f"Video too large: {file_size / 1024 / 1024:.1f}MB (max 14.9MB)"
+            )
+        with open(path, "rb") as f:
+            b64 = base64.b64encode(f.read()).decode("utf-8")
+    else:
+        from PIL import Image
+
+        img = Image.open(path)
+        w, h = img.size
+        if max(w, h) > max_side:
+            scale = max_side / max(w, h)
+            img = img.resize((int(w * scale), int(h * scale)), Image.LANCZOS)
+
+        # 分辨率缩放后，如果体积仍超过 5MB，逐步降低 JPEG quality 压缩到 5MB 以内
+        MAX_BYTES = 5 * 1024 * 1024
+        buf = io.BytesIO()
+        img.save(buf, format=img.format or "PNG")
+
+        if buf.tell() > MAX_BYTES:
+            if img.mode in ("RGBA", "P", "LA"):
+                img = img.convert("RGB")
+            for quality in range(85, 4, -15):
+                buf = io.BytesIO()
+                img.save(buf, format="JPEG", quality=quality)
+                if buf.tell() <= MAX_BYTES:
+                    break
+            mime_type = "image/jpeg"
+
+        b64 = base64.b64encode(buf.getvalue()).decode("utf-8")
+
+    return b64, mime_type
+
+
+# ─── Media path extraction ─────────────────────────────────────
+
+_MEDIA_EXT_PATTERN = "|".join(
+    re.escape(ext.lstrip("."))
+    for ext in sorted(_ALL_MEDIA_EXTS)
+)
+
+_MEDIA_PATH_PATTERN = re.compile(
+    r"(?:"
+    # Quoted path: "path/to/image.png" or 'path\to\image.jpg'
+    # Use [^"']+ to allow spaces inside quoted paths
+    r'(["\'])([^"\']+\.(?:' + _MEDIA_EXT_PATTERN + r'))\1'
+    r"|"
+    # Bare path: must start with /, \, ~, ./, ../, or a drive letter (C:)
+    # This avoids matching URLs or code references like output.png
+    # Note: bare paths cannot contain spaces (use quotes for that)
+    r'((?:[/~\\]|[.]{1,2}[/\\]|[A-Za-z]:[/\\])[^\s]*\.(?:' + _MEDIA_EXT_PATTERN + r'))'
+    r")",
+    re.IGNORECASE,
+)
+
+
+def extract_media_paths(text: str, working_directory: Path) -> list[Path]:
+    """Extract valid media file paths from user input text.
+
+    Returns paths that actually exist on disk, resolved relative
+    to working_directory. Deduplicates results.
+    """
+    found: list[Path] = []
+    seen: set[str] = set()
+
+    for match in _MEDIA_PATH_PATTERN.finditer(text):
+        # Group 1-2: quoted path; Group 3: bare path
+        raw_path = match.group(2) or match.group(3)
+        if not raw_path:
+            continue
+
+        path = Path(raw_path).expanduser()
+        if not path.is_absolute():
+            path = working_directory / path
+
+        path_str = str(path.resolve())
+        if path_str in seen:
+            continue
+
+        if (
+            path.exists()
+            and path.is_file()
+            and path.suffix.lower() in _ALL_MEDIA_EXTS
+        ):
+            seen.add(path_str)
+            found.append(path)
+
+    return found
+
+
+# ─── Multimodal message builder ─────────────────────────────────
+
+
+def build_multimodal_message(
+    text: str,
+    media_paths: list[Path],
+    max_side: int = 2048,
+) -> HumanMessage:
+    """Build a HumanMessage with text and embedded media.
+
+    Image paths in text are replaced with [image: filename].
+    Video paths are replaced with [video: filename].
+    Images use image_url type, videos use video_url type.
+    """
+    content_blocks: list[dict] = []
+
+    # Replace media paths in text with reference markers.
+    # Use single-pass replacement to avoid collision when multiple files
+    # share the same filename (e.g., dir1/test.png and dir2/test.png).
+    # Build a mapping from original text span → marker, then replace
+    # from longest matches first to prevent partial replacements.
+    replacements: list[tuple[str, str]] = []  # (original_text, marker)
+    for media_path in media_paths:
+        is_vid = media_path.suffix.lower() in _VIDEO_EXTS
+        marker = f"[video: {media_path.name}]" if is_vid else f"[image: {media_path.name}]"
+        matched = False
+        # Try quoted and full path representations
+        for sep in [f'"{media_path}"', f"'{media_path}'", str(media_path)]:
+            if sep in text:
+                replacements.append((sep, marker))
+                matched = True
+                break
+        if not matched and media_path.name in text:
+            replacements.append((media_path.name, marker))
+
+    # Sort by length descending so longer paths are replaced first
+    replacements.sort(key=lambda r: len(r[0]), reverse=True)
+    clean_text = text
+    for original, marker in replacements:
+        clean_text = clean_text.replace(original, marker, 1)
+
+    content_blocks.append({"type": "text", "text": clean_text})
+
+    for media_path in media_paths:
+        b64, mime = encode_media_as_base64(media_path, max_side=max_side)
+        data_url = f"data:{mime};base64,{b64}"
+
+        if media_path.suffix.lower() in _VIDEO_EXTS:
+            content_blocks.append({
+                "type": "video_url",
+                "video_url": {"url": data_url},
+            })
+        else:
+            content_blocks.append({
+                "type": "image_url",
+                "image_url": {"url": data_url},
+            })
+
+    return HumanMessage(content=content_blocks)

chcode/utils/shell/__init__.py

@@ -0,0 +1,17 @@
+from chcode.utils.shell.output import TruncatedOutput, truncate_output
+from chcode.utils.shell.provider import BashProvider, PowerShellProvider, ShellProvider
+from chcode.utils.shell.result import ShellResult
+from chcode.utils.shell.semantics import Interpretation, interpret_command_result
+from chcode.utils.shell.session import ShellSession
+
+__all__ = [
+    "ShellProvider",
+    "BashProvider",
+    "PowerShellProvider",
+    "ShellSession",
+    "ShellResult",
+    "Interpretation",
+    "interpret_command_result",
+    "TruncatedOutput",
+    "truncate_output",
+]