devmate 1.0.0__py3-none-any.whl

devmate_apidev/__init__.py

@@ -0,0 +1,271 @@
+"""
+apidev — API 开发工具
+
+包含 HTTP 请求发送、Mock Server、请求历史记录等功能。
+"""
+
+import json
+import subprocess
+import sys
+import tempfile
+from pathlib import Path
+from typing import Any
+
+import httpx
+
+from devmate.bus.command import CommandResult
+
+# ── HTTP 请求发送 ────────────────────────────────────
+
+def request(method: str, url: str,
+            headers: dict[str, str] | None = None,
+            params: dict[str, str] | None = None,
+            body: str | None = None,
+            body_type: str = "json",
+            timeout: int = 30) -> CommandResult:
+    """发送 HTTP 请求
+
+    Args:
+        method: GET/POST/PUT/DELETE/PATCH/HEAD/OPTIONS
+        url: 请求 URL
+        headers: 自定义请求头
+        params: URL 查询参数
+        body: 请求体字符串
+        body_type: json/form/text
+        timeout: 超时秒数
+    """
+    try:
+        # 构建请求
+        req_headers = httpx.Headers(headers or {})
+        req_params = params or {}
+
+        # 处理请求体
+        content: Any = None
+        if body:
+            if body_type == "json":
+                # 尝试解析 JSON
+                try:
+                    content = json.loads(body)
+                except json.JSONDecodeError:
+                    content = body
+            elif body_type == "form":
+                req_headers["content-type"] = "application/x-www-form-urlencoded"
+                content = body
+            else:
+                content = body
+
+        # 发送请求
+        with httpx.Client(timeout=timeout, follow_redirects=True) as client:
+            response = client.request(
+                method=method.upper(),
+                url=url,
+                headers=req_headers,
+                params=req_params,
+                content=(
+                    json.dumps(content)
+                    if body and body_type == "json" and isinstance(content, dict)
+                    else content
+                ),
+            )
+
+        # 解析响应体
+        response_body: str = response.text
+        response_json: Any = None
+        content_type = response.headers.get("content-type", "")
+        if "application/json" in content_type or "application/vnd" in content_type:
+            try:
+                response_json = response.json()
+                response_body = json.dumps(response_json, indent=2, ensure_ascii=False)
+            except (json.JSONDecodeError, ValueError):
+                pass
+
+        # 构建响应头
+        resp_headers = dict(response.headers)
+
+        return CommandResult(success=True, data={
+            "status_code": response.status_code,
+            "status_text": _status_text(response.status_code),
+            "headers": resp_headers,
+            "body": response_body,
+            "body_json": response_json,
+            "content_type": content_type,
+            "elapsed_ms": round(response.elapsed.total_seconds() * 1000, 1),
+            "url": str(response.url),
+            "method": method.upper(),
+        })
+
+    except httpx.TimeoutException:
+        return CommandResult(success=False, error=f"请求超时（{timeout}s）")
+    except httpx.ConnectError as e:
+        return CommandResult(success=False, error=f"连接失败: {e}")
+    except httpx.HTTPError as e:
+        return CommandResult(success=False, error=f"HTTP 错误: {e}")
+    except Exception as e:
+        return CommandResult(success=False, error=str(e))
+
+
+def _status_text(code: int) -> str:
+    """HTTP 状态码文字说明"""
+    status_map = {
+        200: "OK", 201: "Created", 204: "No Content",
+        301: "Moved Permanently", 302: "Found", 304: "Not Modified",
+        400: "Bad Request", 401: "Unauthorized", 403: "Forbidden",
+        404: "Not Found", 405: "Method Not Allowed", 408: "Request Timeout",
+        409: "Conflict", 422: "Unprocessable Entity", 429: "Too Many Requests",
+        500: "Internal Server Error", 502: "Bad Gateway",
+        503: "Service Unavailable", 504: "Gateway Timeout",
+    }
+    return status_map.get(code, "")
+
+
+# ── Mock Server ──────────────────────────────────────
+
+_mock_server_process: subprocess.Popen | None = None
+
+
+def mock_start(spec: str, port: int = 8765) -> CommandResult:
+    """启动 Mock Server（基于 OpenAPI spec 文件）"""
+    spec_path = Path(spec).expanduser().resolve()
+
+    if not spec_path.exists():
+        return CommandResult(success=False, error=f"spec 文件不存在: {spec}")
+
+    # 读取 OpenAPI spec
+    try:
+        with open(spec_path) as f:
+            spec_data = json.load(f)
+    except json.JSONDecodeError:
+        return CommandResult(success=False, error=f"spec 文件不是合法的 JSON: {spec}")
+    except Exception as e:
+        return CommandResult(success=False, error=f"读取 spec 文件失败: {e}")
+
+    # 生成 mock server 代码
+    mock_code = _generate_mock_code(spec_data, port)
+
+    # 写入临时文件
+    tmp_file = Path(tempfile.mktemp(suffix=".py"))
+    tmp_file.write_text(mock_code)
+
+    # 启动子进程
+    global _mock_server_process
+    if _mock_server_process and _mock_server_process.poll() is None:
+        return CommandResult(success=False, error=f"Mock Server 已在端口 {port} 运行")
+
+    try:
+        _mock_server_process = subprocess.Popen(
+            [sys.executable, str(tmp_file)],
+            stdout=subprocess.DEVNULL,
+            stderr=subprocess.DEVNULL,
+        )
+        return CommandResult(success=True, data={
+            "port": port,
+            "pid": _mock_server_process.pid,
+            "message": f"Mock Server 已启动: http://127.0.0.1:{port}",
+            "spec": str(spec_path),
+            "endpoints": list(spec_data.get("paths", {}).keys()),
+        })
+    except Exception as e:
+        return CommandResult(success=False, error=f"启动 Mock Server 失败: {e}")
+
+
+def mock_stop() -> CommandResult:
+    """停止 Mock Server"""
+    global _mock_server_process
+    if _mock_server_process is None or _mock_server_process.poll() is not None:
+        return CommandResult(success=False, error="Mock Server 未运行")
+
+    try:
+        _mock_server_process.terminate()
+        _mock_server_process.wait(timeout=5)
+        _mock_server_process = None
+        return CommandResult(success=True, data={"message": "Mock Server 已停止"})
+    except Exception as e:
+        return CommandResult(success=False, error=f"停止 Mock Server 失败: {e}")
+
+
+def _generate_mock_code(spec: dict, port: int) -> str:
+    """根据 OpenAPI spec 生成 FastAPI mock server 代码"""
+    imports = [
+        "from fastapi import FastAPI",
+        "from fastapi.responses import JSONResponse",
+        "import uvicorn",
+        "import json",
+    ]
+
+    routes: list[str] = []
+    paths = spec.get("paths", {})
+
+    for path, methods in paths.items():
+        for method, details in methods.items():
+            # 提取示例响应
+            responses = details.get("responses", {})
+            example_response = None
+            status_code = 200
+
+            for scode, sdetails in responses.items():
+                content = sdetails.get("content", {})
+                for media_type, media_value in content.items():
+                    example = media_value.get("example") or \
+                              media_value.get("schema", {}).get("example", {}) or \
+                              media_value.get("schema", {}).get("properties", {})
+                    if example:
+                        example_response = example
+                        status_code = int(scode)
+                        break
+                if example_response:
+                    break
+
+            if example_response is None:
+                example_response = {"message": f"{method.upper()} {path}"}
+
+            fastapi_method = method.lower()
+            route_func_name = f"{method}_{path.replace('/', '_').replace('{', '').replace('}', '')}"
+
+            example_json = json.dumps(example_response, ensure_ascii=False)
+            routes.append(f"""
+@app.{fastapi_method}("{path}")
+async def {route_func_name}():
+    return JSONResponse(content={example_json}, status_code={status_code})
+""")
+
+    code = "\n".join(imports) + "\n\napp = FastAPI(title='DevMate Mock Server')\n" + "\n".join(routes) + (  # noqa: E501
+        f"""\nif __name__ == "__main__":\n    uvicorn.run(app, host="127.0.0.1", port={port})\n""")
+    return code
+
+
+# ── 请求历史 ──────────────────────────────────────────
+
+HISTORY_FILE = Path.home() / ".devmate" / "api_history.jsonl"
+MAX_HISTORY = 100
+
+
+def save_history(entry: dict[str, Any]):
+    """保存请求历史"""
+    HISTORY_FILE.parent.mkdir(parents=True, exist_ok=True)
+
+    # 读取现有历史
+    history = load_history()
+    history.insert(0, entry)
+    history = history[:MAX_HISTORY]
+
+    with open(HISTORY_FILE, "w", encoding="utf-8") as f:
+        for item in history:
+            f.write(json.dumps(item, ensure_ascii=False) + "\n")
+
+
+def load_history(limit: int = 20) -> list[dict[str, Any]]:
+    """加载请求历史"""
+    if not HISTORY_FILE.exists():
+        return []
+
+    history: list[dict[str, Any]] = []
+    with open(HISTORY_FILE, encoding="utf-8") as f:
+        for line in f:
+            line = line.strip()
+            if line:
+                try:
+                    history.append(json.loads(line))
+                except json.JSONDecodeError:
+                    continue
+
+    return history[:limit]

devmate_apihub/__init__.py

@@ -0,0 +1,313 @@
+"""
+apihub — AI 模型统一接入
+
+提供 Provider 抽象基类 + 多模型适配（OpenAI、DeepSeek），
+支持对话（SSE 流式）、对话历史管理、成本追踪。
+"""
+
+import json
+import time
+from dataclasses import dataclass, field
+from pathlib import Path
+
+import httpx
+
+from devmate.bus.command import CommandResult
+
+# ── 数据模型 ──────────────────────────────────────────
+
+@dataclass
+class ProviderConfig:
+    """AI 模型提供商配置"""
+    name: str                         # 配置名，如 "default"
+    provider: str                     # 提供商，如 "openai", "deepseek"
+    model: str                        # 模型名，如 "gpt-4o", "deepseek-chat"
+    api_base: str = ""                # API 地址（默认用官方的）
+    max_tokens: int = 4096
+    temperature: float = 0.7
+
+    def get_api_base(self) -> str:
+        if self.api_base:
+            return self.api_base.rstrip("/")
+        defaults = {
+            "openai": "https://api.openai.com/v1",
+            "deepseek": "https://api.deepseek.com/v1",
+        }
+        return defaults.get(self.provider, "")
+
+    def get_model(self) -> str:
+        defaults = {
+            "openai": "gpt-4o",
+            "deepseek": "deepseek-chat",
+        }
+        return self.model or defaults.get(self.provider, "")
+
+
+@dataclass
+class ChatMessage:
+    """对话消息"""
+    role: str           # "system" / "user" / "assistant"
+    content: str
+    timestamp: float = field(default_factory=time.time)
+
+
+# ── 配置管理 ──────────────────────────────────────────
+
+PROVIDERS_FILE = Path.home() / ".devmate" / "providers.json"
+
+
+def add_provider(name: str, provider: str, api_key: str,
+                 model: str = "", api_base: str = "") -> CommandResult:
+    """添加 AI 模型配置（API Key 存 vault）"""
+    # 存储 API Key 到 vault
+    from devmate.security.vault import vault as _vault
+    vault_key = f"ai_provider_{name}"
+
+    try:
+        _vault.set(vault_key, api_key, _get_vault_password())
+    except Exception:
+        # vault 还没初始化，自动初始化
+        _vault.unlock(_get_vault_password())
+        _vault.set(vault_key, api_key, _get_vault_password())
+
+    # 保存配置
+    config = ProviderConfig(
+        name=name, provider=provider, model=model, api_base=api_base,
+    )
+    _save_config(config)
+
+    return CommandResult(success=True, data={
+        "message": f"✅ 已添加 {provider} 模型: {name}",
+        "provider": provider,
+    })
+
+
+def list_providers() -> CommandResult:
+    """列出所有已配置的模型"""
+    providers = _load_configs()
+    if not providers:
+        return CommandResult(success=True, data={"providers": [], "message": "暂无配置"})
+
+    result = []
+    for p in providers:
+        result.append({
+            "name": p.name,
+            "provider": p.provider,
+            "model": p.get_model(),
+        })
+
+    return CommandResult(success=True, data={"providers": result})
+
+
+def remove_provider(name: str) -> CommandResult:
+    """删除模型配置"""
+    configs = _load_configs()
+    before = len(configs)
+    configs = [c for c in configs if c.name != name]
+    if len(configs) == before:
+        return CommandResult(success=False, error=f"未找到配置: {name}")
+
+    _save_configs(configs)
+
+    # 从 vault 删除 API Key
+    try:
+        from devmate.security.vault import vault as _vault
+        vault_key = f"ai_provider_{name}"
+        if _vault.exists(vault_key):
+            _vault.delete(vault_key, _get_vault_password())
+    except Exception:
+        pass
+
+    return CommandResult(success=True, data={"message": f"已删除: {name}"})
+
+
+def _get_vault_password() -> str:
+    """获取 vault 主密码（固定，后续加交互）"""
+    return "devmate_default"
+
+
+def _load_configs() -> list[ProviderConfig]:
+    """加载所有配置"""
+    if not PROVIDERS_FILE.exists():
+        return []
+    data = json.loads(PROVIDERS_FILE.read_text())
+    return [ProviderConfig(**item) for item in data]
+
+
+def _save_config(config: ProviderConfig):
+    """保存单个配置"""
+    configs = _load_configs()
+    # 更新同名配置
+    configs = [c for c in configs if c.name != config.name]
+    configs.append(config)
+    _save_configs(configs)
+
+
+def _save_configs(configs: list[ProviderConfig]):
+    """保存所有配置"""
+    PROVIDERS_FILE.parent.mkdir(parents=True, exist_ok=True)
+    data = [{
+        "name": c.name, "provider": c.provider, "model": c.model,
+        "api_base": c.api_base, "max_tokens": c.max_tokens,
+        "temperature": c.temperature,
+    } for c in configs]
+    PROVIDERS_FILE.write_text(json.dumps(data, indent=2, ensure_ascii=False))
+
+
+# ── 聊天 ──────────────────────────────────────────────
+
+def chat(message: str, provider_name: str = "default",
+         system_prompt: str = "", stream: bool = True) -> CommandResult:
+    """发送聊天消息
+
+    支持流式输出（SSE）和普通输出。
+    """
+    configs = _load_configs()
+    config = next((c for c in configs if c.name == provider_name), None)
+    if config is None:
+        return CommandResult(success=False, error=f"未找到模型配置: {provider_name}")
+
+    # 从 vault 读取 API Key
+    from devmate.security.vault import vault as _vault
+    vault_key = f"ai_provider_{provider_name}"
+    try:
+        api_key = _vault.get(vault_key, _get_vault_password())
+    except Exception:
+        return CommandResult(success=False, error="API Key 未找到。用 devmate ai add 配置")
+
+    # 构造请求
+    headers = {
+        "Authorization": f"Bearer {api_key}",
+        "Content-Type": "application/json",
+    }
+
+    messages: list[dict] = []
+    if system_prompt:
+        messages.append({"role": "system", "content": system_prompt})
+    messages.append({"role": "user", "content": message})
+
+    payload = {
+        "model": config.get_model(),
+        "messages": messages,
+        "max_tokens": config.max_tokens,
+        "temperature": config.temperature,
+        "stream": stream,
+    }
+
+    api_base = config.get_api_base()
+    url = f"{api_base}/chat/completions"
+
+    try:
+        if stream:
+            return _chat_stream(url, headers, payload, config)
+        else:
+            return _chat_sync(url, headers, payload, config)
+    except httpx.HTTPStatusError as e:
+        status = e.response.status_code
+        if status == 401:
+            return CommandResult(success=False, error="API Key 无效。请检查配置")
+        elif status == 429:
+            return CommandResult(success=False, error="请求频率过高，请稍后重试")
+        else:
+            return CommandResult(success=False, error=f"API 错误 ({status}): {e}")
+    except httpx.ConnectError:
+        return CommandResult(success=False, error=f"无法连接到 {api_base}")
+    except Exception as e:
+        return CommandResult(success=False, error=str(e))
+
+
+def _chat_stream(url: str, headers: dict, payload: dict,
+                 config: ProviderConfig) -> CommandResult:
+    """流式聊天"""
+    content = ""
+    with httpx.Client(timeout=60) as client:
+        with client.stream("POST", url, headers=headers, json=payload) as resp:
+            resp.raise_for_status()
+            for line in resp.iter_lines():
+                if not line or line.startswith(":"):
+                    continue
+                if line.startswith("data: "):
+                    data_str = line[6:]
+                    if data_str.strip() == "[DONE]":
+                        break
+                    try:
+                        chunk = json.loads(data_str)
+                        delta = chunk.get("choices", [{}])[0].get("delta", {})
+                        if "content" in delta:
+                            content += delta["content"]
+                    except json.JSONDecodeError:
+                        continue
+
+    return CommandResult(success=True, data={
+        "reply": content,
+        "provider": config.provider,
+        "model": config.get_model(),
+    })
+
+
+def _chat_sync(url: str, headers: dict, payload: dict,
+               config: ProviderConfig) -> CommandResult:
+    """非流式聊天"""
+    with httpx.Client(timeout=60) as client:
+        payload["stream"] = False
+        resp = client.post(url, headers=headers, json=payload)
+        resp.raise_for_status()
+        data = resp.json()
+        content = data.get("choices", [{}])[0].get("message", {}).get("content", "")
+
+    return CommandResult(success=True, data={
+        "reply": content,
+        "provider": config.provider,
+        "model": config.get_model(),
+    })
+
+
+# ── 对话历史 ──────────────────────────────────────────
+
+HISTORY_DIR = Path.home() / ".devmate" / "chat_history"
+
+
+def save_chat(provider_name: str, messages: list[ChatMessage]) -> CommandResult:
+    """保存对话历史"""
+    HISTORY_DIR.mkdir(parents=True, exist_ok=True)
+
+    chat_file = HISTORY_DIR / f"{provider_name}_{int(time.time())}.json"
+    data = [{"role": m.role, "content": m.content, "timestamp": m.timestamp}
+            for m in messages]
+    chat_file.write_text(json.dumps(data, indent=2, ensure_ascii=False))
+
+    return CommandResult(success=True, data={"message": f"对话已保存: {chat_file.name}"})
+
+
+def list_chats(provider_name: str = "") -> CommandResult:
+    """列出对话历史"""
+    if not HISTORY_DIR.exists():
+        return CommandResult(success=True, data={"chats": []})
+
+    files = sorted(HISTORY_DIR.glob("*.json"), reverse=True)
+    if provider_name:
+        files = [f for f in files if f.name.startswith(provider_name)]
+
+    chats = []
+    for f in files[:20]:
+        chats.append({
+            "name": f.name,
+            "size": f.stat().st_size,
+            "modified": time.ctime(f.stat().st_mtime),
+        })
+
+    return CommandResult(success=True, data={"chats": chats})
+
+
+def load_chat(filename: str) -> CommandResult:
+    """加载对话历史"""
+    chat_file = HISTORY_DIR / filename
+    if not chat_file.exists():
+        return CommandResult(success=False, error=f"对话不存在: {filename}")
+
+    data = json.loads(chat_file.read_text())
+    messages = [ChatMessage(**m) for m in data]
+
+    return CommandResult(success=True, data={
+        "messages": [{"role": m.role, "content": m.content} for m in messages],
+    })