super-code-assistant 3.3.6__py3-none-any.whl

core/file_state.py

@@ -0,0 +1,279 @@
+"""Snippet 系统核心数据模型 —— 会话级文件状态 & 编辑凭证追踪。
+
+Phase 1: 基础数据模型 + read 集成。
+Phase 2: edit 接入。
+Phase 3: write 刷新 + engine 集成 + /resume 重建。
+Phase 4: compact 失效 + 边界情况。
+
+设计原则：
+- read 时创建 snippet（含行范围 + 文件版本号），作为"编辑凭证"
+- edit 必须在 snippet 限定的行范围内搜索替换
+- 文件被修改后旧 snippet 自动失效（version 不匹配）
+- 会话恢复时从 JSONL 历史重建注册表
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Dict, Optional
+
+# ---------------------------------------------------------------------------
+# 数据类
+# ---------------------------------------------------------------------------
+
+
+@dataclass
+class FileState:
+    """会话内文件的缓存状态。"""
+
+    file_path: str
+    content: str
+    mtime: float          # 读取时的文件修改时间
+    version: int = 1      # 会话内修改次数（每次 edit/write 后 +1）
+    encoding: str = "utf-8"
+    line_endings: str = "LF"  # "LF" | "CRLF"（Phase 4 编辑时保留换行符用）
+
+
+@dataclass
+class FileSnippet:
+    """一次 read 操作生成的"编辑凭证"。
+
+    edit 必须携带有效的 snippet_id，且替换仅在 [start_line, end_line] 范围内搜索。
+    file_version 用于检测"自读取后文件是否被修改过"。
+    """
+
+    id: str               # "snp_3" 或 "full_0"
+    file_path: str
+    start_line: int       # 1-based
+    end_line: int         # 1-based, inclusive
+    file_version: int     # 创建时的文件版本号
+    scope_type: str       # "full"（全文件）或 "snippet"（部分）
+
+
+# ---------------------------------------------------------------------------
+# 模块级注册表（按 session_id 隔离）
+# ---------------------------------------------------------------------------
+
+# file_path → FileState
+_file_states: Dict[str, Dict[str, FileState]] = {}
+
+# snippet_id → FileSnippet
+_snippets: Dict[str, Dict[str, FileSnippet]] = {}
+
+# file_path → 当前 version
+_file_versions: Dict[str, Dict[str, int]] = {}
+
+# 每个 session 的 snippet 计数器
+_snippet_counters: Dict[str, int] = {}
+_full_counters: Dict[str, int] = {}
+
+
+# ---------------------------------------------------------------------------
+# 公开 API
+# ---------------------------------------------------------------------------
+
+
+def _ensure_session(session_id: str) -> None:
+    """惰性初始化 session 的所有 dict。"""
+    if session_id not in _file_states:
+        _file_states[session_id] = {}
+        _snippets[session_id] = {}
+        _file_versions[session_id] = {}
+        _snippet_counters[session_id] = 0
+        _full_counters[session_id] = 0
+
+
+def clear_session_state(session_id: str) -> None:
+    """清空指定会话的所有状态。"""
+    _file_states.pop(session_id, None)
+    _snippets.pop(session_id, None)
+    _file_versions.pop(session_id, None)
+    _snippet_counters.pop(session_id, None)
+    _full_counters.pop(session_id, None)
+
+
+# --- 文件版本 ---
+
+
+def get_file_version(session_id: str, file_path: str) -> int:
+    """获取文件当前版本号（未记录则返回 0）。"""
+    return _file_versions.get(session_id, {}).get(_normalize(file_path), 0)
+
+
+def _bump_file_version(session_id: str, file_path: str) -> int:
+    """自增版本号并返回新值。"""
+    key = _normalize(file_path)
+    versions = _file_versions.setdefault(session_id, {})
+    versions[key] = versions.get(key, 0) + 1
+    return versions[key]
+
+
+# --- 文件状态 ---
+
+
+def record_file_state(
+    session_id: str,
+    file_path: str,
+    content: str,
+    mtime: float = 0.0,
+    *,
+    bump_version: bool = False,
+) -> FileState:
+    """记录文件当前状态。bump_version=True 时自增版本号（edit/write 后调用）。
+
+    首次记录时版本号默认1为 1（非 0），确保 snippet 版本校验的初始状态正确。
+    """
+    _ensure_session(session_id)
+    key = _normalize(file_path)
+    versions = _file_versions[session_id]
+    if key not in versions:
+        versions[key] = 1  # 首次记录初始化为 1
+    if bump_version:
+        _bump_file_version(session_id, file_path)
+    state = FileState(
+        file_path=key,
+        content=content,
+        mtime=mtime,
+        version=get_file_version(session_id, file_path),
+    )
+    _file_states[session_id][key] = state
+    return state
+
+
+def get_file_state(session_id: str, file_path: str) -> Optional[FileState]:
+    """获取文件状态（未记录则返回 None）。"""
+    return _file_states.get(session_id, {}).get(_normalize(file_path))
+
+
+def file_was_read(session_id: str, file_path: str) -> bool:
+    """文件是否在当前会话中被读过。"""
+    return get_file_state(session_id, file_path) is not None
+
+
+# --- Snippet ---
+
+
+def create_snippet(
+    session_id: str,
+    file_path: str,
+    start_line: int,
+    end_line: int,
+    *,
+    scope_type: str = "snippet",
+) -> FileSnippet:
+    """为一次 read 操作创建编辑凭证。
+
+    读全文件时 scope_type="full"，部分读时 scope_type="snippet"。
+    """
+    _ensure_session(session_id)
+    key = _normalize(file_path)
+    version = get_file_version(session_id, file_path)
+
+    if scope_type == "full":
+        _full_counters[session_id] += 1
+        sid = f"full_{_full_counters[session_id] - 1}"
+    else:
+        _snippet_counters[session_id] += 1
+        sid = f"snp_{_snippet_counters[session_id] - 1}"
+
+    snippet = FileSnippet(
+        id=sid,
+        file_path=key,
+        start_line=start_line,
+        end_line=end_line,
+        file_version=version,
+        scope_type=scope_type,
+    )
+    _snippets[session_id][sid] = snippet
+    return snippet
+
+
+def get_snippet(session_id: str, snippet_id: str) -> Optional[FileSnippet]:
+    """按 id 查找 snippet。"""
+    return _snippets.get(session_id, {}).get(snippet_id)
+
+
+def is_snippet_stale(session_id: str, snippet: FileSnippet) -> bool:
+    """snippet 是否已过期（文件版本升级）。"""
+    current_version = get_file_version(session_id, snippet.file_path)
+    return current_version > snippet.file_version
+
+
+def invalidate_snippets_for_file(session_id: str, file_path: str) -> None:
+    """让某个文件的所有已存在 snippet 失效（通过将 file_version 设为极高值）。
+
+    注意：已存在的 snippet 实例不会变，但后续 is_snippet_stale() 会因为
+    file_version 不匹配而返回 True。
+    """
+    _ensure_session(session_id)
+    key = _normalize(file_path)
+    # 将版本号设为极大值，让所有旧 snippet 失效
+    _file_versions.setdefault(session_id, {})[key] = 999_999_999
+
+
+def invalidate_all_snippets(session_id: str) -> None:
+    """失效当前会话所有已存在 snippet（Phase 4: compact 后调用）。
+
+    将所有已追踪文件的版本号设为极大值，让 compact 前的所有 snippet 全部过期。
+    模型必须重新 read 才能获得新的有效 snippet。
+    """
+    _ensure_session(session_id)
+    for key in list(_file_versions.get(session_id, {})):
+        _file_versions[session_id][key] = 999_999_999
+
+
+# --- 会话恢复（Phase 3 用到，提前定义接口）---
+
+
+def rebuild_snippet(
+    session_id: str,
+    snippet_id: str,
+    file_path: str,
+    start_line: int,
+    end_line: int,
+    scope_type: str = "snippet",
+) -> Optional[FileSnippet]:
+    """从 JSONL 历史重建一个 snippet（会话恢复时使用）。"""
+    _ensure_session(session_id)
+    key = _normalize(file_path)
+    version = get_file_version(session_id, file_path)
+
+    snippet = FileSnippet(
+        id=snippet_id,
+        file_path=key,
+        start_line=start_line,
+        end_line=end_line,
+        file_version=version,
+        scope_type=scope_type,
+    )
+    _snippets[session_id][snippet_id] = snippet
+
+    # 调整计数器，避免 id 冲突
+    if snippet_id.startswith("full_"):
+        try:
+            num = int(snippet_id.split("_", 1)[1]) + 1
+            _full_counters[session_id] = max(_full_counters.get(session_id, 0), num)
+        except ValueError:
+            pass
+    elif snippet_id.startswith("snp_"):
+        try:
+            num = int(snippet_id.rsplit("_", 1)[1]) + 1
+            _snippet_counters[session_id] = max(_snippet_counters.get(session_id, 0), num)
+        except ValueError:
+            pass
+
+    return snippet
+
+
+# ---------------------------------------------------------------------------
+# 内部工具
+# ---------------------------------------------------------------------------
+
+
+def _normalize(file_path: str) -> str:
+    """用 resolve 后的绝对路径做 key，避免同一个文件因相对/绝对路径不同被记成两条。"""
+    try:
+        return str(Path(file_path).resolve())
+    except Exception:
+        return file_path

core/llm.py

@@ -0,0 +1,309 @@
+import json
+from dataclasses import dataclass
+from typing import Any, Optional, Iterator
+
+from openai import OpenAI
+
+# Provider，目前只实现openai，后续接入其他厂商
+OPENAI = 'openai'
+VALID_PROVIDERS = [OPENAI]
+
+
+def validate_provider(provider):
+    if provider not in VALID_PROVIDERS:
+        raise ValueError(f"Invalid provider: {provider}")
+    return provider
+
+
+@dataclass
+class StreamMessage:
+    """Represents the final message from a stream."""
+    content: Any
+    usage: Any | None = None
+    reasoning_content: str | None = None  # DeepSeek 等思考模型的推理内容，需原样透传
+
+
+class OpenAIStream:
+
+    def __init__(self, *,
+                 client: Any,
+                 model: str,
+                 messages: list[dict[str, Any]],
+                 temperature: float = 0.7,
+                 max_tokens: Optional[int] = None,
+                 tools: Optional[list[dict]] = None,
+                 extra_body: Optional[dict] = None):
+        self._client = client
+        self._params = {
+            "model": model,
+            "messages": messages,
+            "temperature": temperature,
+            "max_tokens": max_tokens,
+            "stream": True,
+        }
+        
+        # 添加工具参数
+        if tools:
+            self._params["tools"] = tools
+            self._params["tool_choice"] = "auto"
+
+        # 模型特定额外参数（如 GLM thinking 控制）
+        if extra_body:
+            self._params["extra_body"] = extra_body
+
+        # 请求流式 usage 数据（OpenAI 需要显式开启）
+        self._params["stream_options"] = {"include_usage": True}
+
+        self._stream = None
+        self._text_parts: list[str] = []
+        self._reasoning_parts: list[str] = []  # 捕获 reasoning_content（DeepSeek 思考模型）
+        self._tool_calls: dict[int, dict[str, Any]] = {}
+        self._usage: dict[str, int] | None = None
+
+    def __enter__(self) -> "OpenAIStream":
+        self._stream = self._client.chat.completions.create(**self._params)
+        return self
+
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        self.close()
+        return False
+
+    def close(self):
+        if self._stream and hasattr(self._stream, "close"):
+            self._stream.close()
+
+    def __iter__(self) -> Iterator[str]:
+        _toolgen_sent = False
+        for chunk in self._stream:
+            # 从流式响应中捕获 usage 数据
+            usage = getattr(chunk, "usage", None)
+            if usage is not None:
+                self._usage = {
+                    "input_tokens": getattr(usage, "prompt_tokens", 0) or 0,
+                    "output_tokens": getattr(usage, "completion_tokens", 0) or 0,
+                }
+            for choice in _value(chunk, "choices", []) or []:
+                delta = _value(choice, "delta", {}) or {}
+                content = _value(delta, "content")
+                if content:
+                    self._text_parts.append(content)
+                    yield content
+                # 捕获 reasoning_content（DeepSeek 思考模型），yield 事件供 TUI 显示进度
+                reasoning = _value(delta, "reasoning_content")
+                if reasoning:
+                    self._reasoning_parts.append(reasoning)
+                    yield f"\x00thinking\x00{reasoning}"
+                for tool_call in _value(delta, "tool_calls", []) or []:
+                    # 首次生成 tool_call 时发送 sentinel，让上层提前显示等待指示
+                    if not _toolgen_sent:
+                        _toolgen_sent = True
+                        yield "\x00toolgen\x00"
+                    index = int(_value(tool_call, "index", 0) or 0)
+                    entry = self._tool_calls.setdefault(index, {
+                        "id": "",
+                        "name": "",
+                        "arguments": "",
+                    })
+                    tool_id = _value(tool_call, "id")
+                    if tool_id:
+                        entry["id"] = tool_id
+                    function = _value(tool_call, "function", {}) or {}
+                    name = _value(function, "name")
+                    if name:
+                        entry["name"] = name
+                    arguments = _value(function, "arguments")
+                    if arguments:
+                        entry["arguments"] += arguments
+
+    # 获取完整响应
+    def final(self) -> StreamMessage:
+        content: list[dict[str, Any]] = []
+        text = "".join(self._text_parts)
+        if text:
+            content.append({"type": "text", "text": text})
+        for index in sorted(self._tool_calls):
+            tool_call = self._tool_calls[index]
+            raw_args = tool_call.get("arguments", "").strip()
+            parsed_args: Any = {}
+            if raw_args:
+                try:
+                    parsed_args = json.loads(raw_args)
+                except json.JSONDecodeError:
+                    parsed_args = {}
+            content.append({
+                "type": "tool_use",
+                "id": tool_call.get("id", ""),
+                "name": tool_call.get("name", ""),
+                "input": parsed_args if isinstance(parsed_args, dict) else {},
+            })
+        return StreamMessage(content=content, usage=self._usage,
+                             reasoning_content="".join(self._reasoning_parts) or None)
+
+
+def _lookup_extra_body(model: str, profiles: dict) -> Optional[dict]:
+    """按模型名子串匹配 model_profiles，最长 key 优先（精确优先），大小写不敏感。"""
+    for key in sorted(profiles, key=len, reverse=True):
+        if key.lower() in model.lower():
+            eb = profiles[key].get("extra_body")
+            return eb if eb else None
+    return None
+
+
+# 构建客户端
+class LLMClient:
+    def __init__(self, *, provider: str, api_key: Optional[str] = None, base_url: Optional[str] = None,
+                 timeout: float = 300.0, model_profiles: Optional[dict] = None):
+        self.provider = validate_provider(provider)
+        self._model_profiles: dict = model_profiles or {}
+        if self.provider == OPENAI:
+            self._client = OpenAI(api_key=api_key, base_url=base_url, timeout=timeout)
+
+    # 非流式输出（用于 compact 摘要等场景）
+    def create(self, *, model: str, max_tokens: int, messages: list[dict[str, Any]],
+               system: str | None = None, strip_thinking: bool = False) -> "StreamMessage":
+        if self.provider == OPENAI:
+            params: dict[str, Any] = {
+                "model": model,
+                "messages": _to_openai_messages(system, messages),
+                "max_tokens": max_tokens,
+            }
+            # 摘要等场景不需要思考：跳过 model_profiles（extra_body 均为思考控制参数），
+            # 走 API 默认（非思考）路径——思考模型非流式会全量输出到 reasoning_content、
+            # content 为空 → 摘要为空。
+            if not strip_thinking:
+                eb = _lookup_extra_body(model, self._model_profiles)
+                if eb:
+                    params["extra_body"] = eb
+            resp = self._client.chat.completions.create(**params)
+            choice = resp.choices[0].message if resp.choices else None
+            text = (choice.content or "") if choice else ""
+            # 非流式响应同样捕获 usage（DeepSeek/OpenAI 均返回 prompt_tokens），
+            # 归一化字段名与流式路径（__iter__）保持一致；无 usage 时保持 None。
+            usage = None
+            raw_usage = getattr(resp, "usage", None)
+            if raw_usage is not None:
+                usage = {
+                    "input_tokens": getattr(raw_usage, "prompt_tokens", 0) or 0,
+                    "output_tokens": getattr(raw_usage, "completion_tokens", 0) or 0,
+                }
+            return StreamMessage(content=[{"type": "text", "text": text}], usage=usage)
+        raise NotImplementedError(f"create not implemented for provider: {self.provider}")
+
+    # 流式输出
+    def stream(self, *, model: str, system_prompt: str, messages: list[dict[str, Any]], temperature: float = 0.7,
+               max_tokens: Optional[int] = None, tools: Optional[list[dict]] = None) -> "OpenAIStream":
+        if self.provider == OPENAI:
+            return OpenAIStream(
+                client=self._client,
+                model=model,
+                max_tokens=max_tokens,
+                messages=_to_openai_messages(system_prompt, messages),
+                temperature=temperature,
+                tools=tools,
+                extra_body=_lookup_extra_body(model, self._model_profiles),
+            )
+        return NotImplementedError
+
+def _value(obj: Any, key: str, default: Any = None) -> Any:
+    if obj is None:
+        return default
+    if isinstance(obj, dict):
+        return obj.get(key, default)
+    return getattr(obj, key, default)
+
+def _to_openai_messages(system: str | None, messages: list[dict[str, Any]]) -> list[dict[str, Any]]:
+    out: list[dict[str, Any]] = []
+    if system:
+        out.append({"role": "system", "content": system})
+
+    for message in messages:
+        role = message.get("role")
+        content = message.get("content", "")
+
+        if role == "user" and isinstance(content, list):
+            tool_results = [
+                block for block in content
+                if isinstance(block, dict) and block.get("type") == "tool_result"
+            ]
+            if tool_results and len(tool_results) == len(content):
+                for block in tool_results:
+                    out.append({
+                        "role": "tool",
+                        "tool_call_id": block.get("tool_use_id", ""),
+                        "content": _tool_result_to_text(block.get("content", "")),
+                    })
+                continue
+
+            out.append({
+                "role": "user",
+                "content": _user_content_blocks_to_openai(content),
+            })
+            continue
+
+        if role == "assistant" and isinstance(content, list):
+            text_parts: list[str] = []
+            tool_calls: list[dict[str, Any]] = []
+            for block in content:
+                if not isinstance(block, dict):
+                    continue
+                block_type = block.get("type")
+                if block_type == "text":
+                    text_parts.append(block.get("text", ""))
+                elif block_type == "tool_use":
+                    tool_calls.append({
+                        "id": block.get("id", ""),
+                        "type": "function",
+                        "function": {
+                            "name": block.get("name", ""),
+                            "arguments": json.dumps(block.get("input", {}), ensure_ascii=False),
+                        },
+                    })
+            text = "".join(text_parts)
+            assistant_message: dict[str, Any] = {"role": "assistant"}
+            if text:
+                assistant_message["content"] = text
+            elif not tool_calls:
+                assistant_message["content"] = ""
+            if tool_calls:
+                assistant_message["tool_calls"] = tool_calls
+            # 透传 reasoning_content（DeepSeek 要求下一轮必须带回）
+            if message.get("reasoning_content"):
+                assistant_message["reasoning_content"] = message["reasoning_content"]
+            out.append(assistant_message)
+            continue
+
+        out.append({
+            "role": role,
+            "content": content,
+        })
+
+    return out
+
+
+def _user_content_blocks_to_openai(content: list[Any]) -> list[dict[str, Any]]:
+    parts: list[dict[str, Any]] = []
+    for block in content:
+        if not isinstance(block, dict):
+            continue
+        block_type = block.get("type")
+        if block_type == "text":
+            parts.append({"type": "text", "text": block.get("text", "")})
+        elif block_type == "image":
+            source = block.get("source", {})
+            media_type = source.get("media_type", "image/png")
+            data = source.get("data", "")
+            parts.append({
+                "type": "image_url",
+                "image_url": {"url": f"data:{media_type};base64,{data}"},
+            })
+    if not parts:
+        return [{"type": "text", "text": ""}]
+    return parts
+
+def _tool_result_to_text(content: Any) -> str:
+    if isinstance(content, str):
+        return content
+    if content is None:
+        return ""
+    return json.dumps(content, ensure_ascii=False)

core/model_capabilities.py

@@ -0,0 +1,45 @@
+"""模型能力表：静态判断常见模型是否支持视觉输入（supports_vision）。
+
+业界 Aider 同款做法（model-metadata.json 的 supports_vision 标记）。本表只做
+"确定支持 / 确定不支持"的保守判断；**未知模型返回 None，由调用方默认放行**
+（试一次，API 400 再提示），避免误伤新模型。
+
+匹配规则：子串匹配 + 长度倒序（先精确后宽松）。大小写不敏感。
+"""
+from __future__ import annotations
+
+# 确定支持视觉的模型关键词（按长度倒序匹配，长 key 优先）
+_VISION_KEYS = sorted([
+    # 智谱 GLM
+    "glm-4v", "glm-4.5v", "glm-4.6v", "glm-5v",
+    # 阿里 Qwen-VL
+    "qwen-vl", "qwen2-vl", "qwen2.5-vl", "qwen3-vl",
+    # DeepSeek
+    "deepseek-vl", "deepseek-v4-flash-vision",
+    # 兜底：型号名自带 vision / vl 特征（实验版、定制名）
+    "vision", "-vl",
+], key=len, reverse=True)
+
+# 确定不支持视觉的模型关键词（仅列明确文本为主的老型号）
+_NON_VISION_KEYS = sorted([
+    "gpt-3.5",
+    "deepseek-chat", "deepseek-reasoner", "deepseek-v3",
+], key=len, reverse=True)
+
+
+def supports_vision(model: str) -> bool | None:
+    """判断模型是否支持视觉输入。
+
+    Returns:
+        True 支持 / False 不支持 / None 未知（调用方默认放行）。
+    """
+    if not model:
+        return None
+    m = model.lower()
+    for key in _VISION_KEYS:
+        if key in m:
+            return True
+    for key in _NON_VISION_KEYS:
+        if key in m:
+            return False
+    return None