auto-coder 1.0.0__py3-none-any.whl → 2.0.0__py3-none-any.whl

autocoder/models.py

@@ -1,117 +1,40 @@
 import os
 import json
-from typing import List, Dict
+from typing import List, Dict, Optional, Union, cast
 from urllib.parse import urlparse
+from autocoder.common.llms import LLMManager, LLMModel
 
+# Backward compatibility - preserve the path constant
 MODELS_JSON = os.path.expanduser("~/.auto-coder/keys/models.json")
 
-# Default built-in models
-default_models_list = [
-    {
-        "name": "deepseek/r1",
-        "description": "DeepSeek Reasoner is for design/review",
-        "model_name": "deepseek-reasoner",
-        "model_type": "saas/openai",
-        "base_url": "https://api.deepseek.com/v1",
-        "api_key_path": "api.deepseek.com",
-        "is_reasoning": True,
-        "input_price": 0.0,  # 单位:M/百万 input tokens
-        "output_price": 0.0,  # 单位:M/百万 output tokens
-        "average_speed": 0.0,  # 单位:秒/请求
-        "max_output_tokens": 8096
-    },    
-    {
-        "name": "deepseek/v3",
-        "description": "DeepSeek Chat is for coding",
-        "model_name": "deepseek-chat",
-        "model_type": "saas/openai",
-        "base_url": "https://api.deepseek.com/v1",
-        "api_key_path": "api.deepseek.com",
-        "is_reasoning": False,
-        "input_price": 0.0,
-        "output_price": 0.0,
-        "average_speed": 0.0,
-        "max_output_tokens": 8096
-    },
-    {
-        "name": "ark/deepseek-v3-250324",
-        "description": "DeepSeek Chat is for coding",
-        "model_name": "deepseek-v3-250324",
-        "model_type": "saas/openai",
-        "base_url": "https://ark.cn-beijing.volces.com/api/v3",
-        "api_key_path": "",
-        "is_reasoning": False,
-        "input_price": 2.0,
-        "output_price": 8.0,
-        "average_speed": 0.0,
-        "max_output_tokens": 8096
-    },    
-    {
-        "name": "ark/deepseek-r1-250120",
-        "description": "DeepSeek Reasoner is for design/review",
-        "model_name": "deepseek-r1-250120",
-        "model_type": "saas/openai",
-        "base_url": "https://ark.cn-beijing.volces.com/api/v3",
-        "api_key_path": "",
-        "is_reasoning": True,
-        "input_price": 4.0,
-        "output_price": 16.0,
-        "average_speed": 0.0,
-        "max_output_tokens": 8096
-    },    
-    {
-        "name": "openai/gpt-4.1-mini",
-        "description": "",
-        "model_name": "openai/gpt-4.1-mini",
-        "model_type": "saas/openai",
-        "base_url": "https://openrouter.ai/api/v1",
-        "api_key_path": "",
-        "is_reasoning": False,
-        "input_price": 2.8,
-        "output_price": 11.2,
-        "average_speed": 0.0,
-        "max_output_tokens": 8096*3
-    },
-    {
-        "name": "openai/gpt-4.1",
-        "description": "",
-        "model_name": "openai/gpt-4.1",
-        "model_type": "saas/openai",
-        "base_url": "https://openrouter.ai/api/v1",
-        "api_key_path": "",
-        "is_reasoning": False,
-        "input_price": 14.0,
-        "output_price": 42.0,
-        "average_speed": 0.0,
-        "max_output_tokens": 8096*3
-    },   
-    {
-        "name": "openai/gpt-4.1-nano",
-        "description": "",
-        "model_name": "openai/gpt-4.1-nano",
-        "model_type": "saas/openai",
-        "base_url": "https://openrouter.ai/api/v1",
-        "api_key_path": "",
-        "is_reasoning": False,
-        "input_price": 0.0,
-        "output_price": 0.0,
-        "average_speed": 0.0,
-        "max_output_tokens": 8096*3
-    },  
-    {
-        "name": "openrouter/google/gemini-2.5-pro-preview-03-25",
-        "description": "",
-        "model_name": "google/gemini-2.5-pro-preview-03-25",
-        "model_type": "saas/openai",
-        "base_url": "https://openrouter.ai/api/v1",
-        "api_key_path": "",
-        "is_reasoning": False,
-        "input_price": 0.0,
-        "output_price": 0.0,
-        "average_speed": 0.0,
-        "max_output_tokens": 8096*2
+# Global LLMManager instance for backward compatibility
+_llm_manager = None
+
+def _get_llm_manager() -> LLMManager:
+    """Get or create the global LLMManager instance"""
+    global _llm_manager
+    if _llm_manager is None:
+        _llm_manager = LLMManager()
+    return _llm_manager
+
+def _model_to_dict(model: LLMModel) -> Dict:
+    """Convert LLMModel to dictionary format for backward compatibility"""
+    return {
+        "name": model.name,
+        "description": model.description,
+        "model_name": model.model_name,
+        "model_type": model.model_type,
+        "base_url": model.base_url,
+        "api_key_path": model.api_key_path or "",
+        "is_reasoning": model.is_reasoning,
+        "input_price": model.input_price,
+        "output_price": model.output_price,
+        "average_speed": 0.0,  # Default for backward compatibility
+        "context_window": model.context_window,
+        "provider": model.provider,        
+        "max_output_tokens": model.max_output_tokens,
+        "api_key": model.get_api_key()
     }
-]
 
 def process_api_key_path(base_url: str) -> str:
     """
@@ -135,75 +58,51 @@ def load_models() -> List[Dict]:
     Models are merged and deduplicated based on their name field.
     If file doesn't exist or is invalid, use default_models_list.
     """
-    os.makedirs(os.path.dirname(MODELS_JSON), exist_ok=True)
-    
-    # Start with default models
-    models_dict = {model["name"]: model for model in default_models_list}
-    
-    # If JSON file exists, read and merge with defaults
-    if os.path.exists(MODELS_JSON):
-        try:
-            with open(MODELS_JSON, 'r', encoding='utf-8') as f:
-                custom_models = json.load(f)
-                # Custom models will override defaults with same name
-                for model in custom_models:
-                    model["is_reasoning"] = model.get("is_reasoning", False)
-                    models_dict[model["name"]] = model
-
-        except json.JSONDecodeError:
-            # If JSON is invalid, just use defaults
-            print("JSON is invalid, using defaults")
-            save_models(default_models_list)
-    else:
-        # If file doesn't exist, create it with defaults
-        save_models(default_models_list)
-    
-    # Convert merged dictionary back to list
-    target_models = list(models_dict.values())
-    api_key_dir = os.path.expanduser("~/.auto-coder/keys")
-    for model in target_models:    
-        if model.get("api_key_path",""):           
-            api_key_file = os.path.join(api_key_dir, model["api_key_path"])
-            if os.path.exists(api_key_file):
-                with open(api_key_file, "r", encoding="utf-8") as f:
-                    model["api_key"] = f.read().strip()
-    return target_models
+    lm = _get_llm_manager()
+    models = lm.get_all_models()
+    return [_model_to_dict(model) for model in models.values()]
 
 def save_models(models: List[Dict]) -> None:
     """
     Save models to ~/.auto-coder/keys/models.json
     """
-    os.makedirs(os.path.dirname(MODELS_JSON), exist_ok=True)
-    with open(MODELS_JSON, 'w', encoding='utf-8') as f:
-        json.dump(models, f, indent=2, ensure_ascii=False)
-
+    lm = _get_llm_manager()
+    lm.add_models(cast(List[Union[LLMModel, Dict]], models))
 
 def add_and_activate_models(models: List[Dict]) -> None:
     """
     添加模型
     """
-    exits_models = load_models()
-    for model in models:        
-        if model["name"] not in [m["name"] for m in exits_models]:
-            exits_models.append(model)
-    save_models(exits_models)
-
-    for model in models:
-        if "api_key" in model:
-            update_model_with_api_key(model["name"], model["api_key"])
+    lm = _get_llm_manager()
+    
+    # First, get existing models to avoid duplicates
+    existing_models = lm.get_all_models()
+    new_models = []
+    
+    for model_data in models:
+        if model_data["name"] not in existing_models:
+            new_models.append(model_data)
+    
+    if new_models:
+        lm.add_models(new_models)
+    
+    # Handle API keys separately for existing models
+    for model_data in models:
+        if "api_key" in model_data and model_data["api_key"]:
+            lm.update_model_with_api_key(model_data["name"], model_data["api_key"])
 
 def get_model_by_name(name: str) -> Dict:
     """
     根据模型名称查找模型
     """
     from autocoder.common.auto_coder_lang import get_message_with_format
-    models = load_models()
-    v = [m for m in models if m["name"] == name.strip()]
+    lm = _get_llm_manager()
+    model = lm.get_model(name.strip())
     
-    if len(v) == 0:        
+    if not model:
         raise Exception(get_message_with_format("model_not_found", model_name=name))
-    return v[0]
-
+    
+    return _model_to_dict(model)
 
 def update_model_input_price(name: str, price: float) -> bool:
     """更新模型输入价格
@@ -229,17 +128,9 @@ def update_model_input_price(name: str, price: float) -> bool:
     """
     if price < 0:
         raise ValueError("Price cannot be negative")
-        
-    models = load_models()
-    updated = False
-    for model in models:
-        if model["name"] == name:
-            model["input_price"] = float(price)
-            updated = True
-            break
-    if updated:
-        save_models(models)
-    return updated
+    
+    lm = _get_llm_manager()
+    return lm.update_input_price(name, price)
 
 def update_model_output_price(name: str, price: float) -> bool:
     """更新模型输出价格
@@ -265,17 +156,9 @@ def update_model_output_price(name: str, price: float) -> bool:
     """
     if price < 0:
         raise ValueError("Price cannot be negative")
-        
-    models = load_models()
-    updated = False
-    for model in models:
-        if model["name"] == name:
-            model["output_price"] = float(price)
-            updated = True
-            break
-    if updated:
-        save_models(models)
-    return updated
+    
+    lm = _get_llm_manager()
+    return lm.update_output_price(name, price)
 
 def update_model_speed(name: str, speed: float) -> bool:
     """更新模型平均速度
@@ -286,26 +169,20 @@ def update_model_speed(name: str, speed: float) -> bool:
         
     Returns:
         bool: 是否更新成功
-    """            
-    models = load_models()
-    updated = False
-    for model in models:
-        if model["name"] == name:
-            model["average_speed"] = float(speed)
-            updated = True
-            break
-    if updated:
-        save_models(models)
-    return updated
+    """
+    lm = _get_llm_manager()
+    # Since the new schema doesn't have average_speed, we'll use update_model
+    # with a custom field or just return True for backward compatibility
+    return lm.check_model_exists(name)  # Just check if model exists
 
 def check_model_exists(name: str) -> bool:
     """
     检查模型是否存在
     """
-    models = load_models()
-    return any(m["name"] == name.strip() for m in models)
+    lm = _get_llm_manager()
+    return lm.check_model_exists(name.strip())
 
-def update_model_with_api_key(name: str, api_key: str) -> Dict:
+def update_model_with_api_key(name: str, api_key: str) -> Optional[Dict]:
     """
     根据模型名称查找并更新模型的 api_key_path。
     如果找到模型,会根据其 base_url 处理 api_key_path。
@@ -317,44 +194,23 @@ def update_model_with_api_key(name: str, api_key: str) -> Dict:
     Returns:
         Dict: 更新后的模型信息,如果未找到则返回None
     """
-    models = load_models()
+    lm = _get_llm_manager()
     
-    # 在现有模型中查找
-    found_model = None
-    for model in models:
-        if model["name"] == name.strip():
-            found_model = model
-            break
-                    
-    if not found_model:
+    # Check if model exists
+    if not lm.check_model_exists(name.strip()):
         return None
-            
-    api_key_path = name.replace("/", "_")  # 替换 / 为 _，保证文件名合法
-    if api_key_path:
-        found_model["api_key_path"] = api_key_path
-        
-        # 保存 API 密钥
-        api_key_dir = os.path.expanduser("~/.auto-coder/keys")
-        os.makedirs(api_key_dir, exist_ok=True)
-        api_key_file = os.path.join(api_key_dir, api_key_path)
-        with open(api_key_file, "w",encoding="utf-8") as f:
-            f.write(api_key.strip())
-        
-        # 如果是新模型，添加到模型列表中
-        if all(model["name"] != name for model in models):
-            models.append(found_model)
-        else:
-            # 更新现有模型
-            for i, model in enumerate(models):
-                if model["name"] == name:
-                    models[i] = found_model
-                    break
-        
-        save_models(models)
     
-    return found_model
+    # Update API key
+    success = lm.update_model_with_api_key(name.strip(), api_key)
+    
+    if success:
+        # Return the updated model as dict for backward compatibility
+        model = lm.get_model(name.strip())
+        return _model_to_dict(model) if model else None
+    
+    return None
 
-def update_model(name: str, model_data: Dict) -> Dict:
+def update_model(name: str, model_data: Dict) -> Optional[Dict]:
     """
     更新模型信息
     
@@ -371,50 +227,23 @@ def update_model(name: str, model_data: Dict) -> Dict:
             - input_price: 输入价格
             - output_price: 输出价格
             - max_output_tokens: 最大输出tokens
-            - average_speed: 平均速度
+            - average_speed: 平均速度（向后兼容，但不会保存）
             
     Returns:
         Dict: 更新后的模型信息，如果未找到则返回None
     """
-    models = load_models()
+    lm = _get_llm_manager()
     
-    # 查找要更新的模型
-    found = False
-    for i, model in enumerate(models):
-        if model["name"] == name:
-            # 更新模型字段
-            if "description" in model_data:
-                model["description"] = model_data["description"]
-            if "model_name" in model_data:
-                model["model_name"] = model_data["model_name"]
-            if "model_type" in model_data:
-                model["model_type"] = model_data["model_type"]
-            if "base_url" in model_data:
-                model["base_url"] = model_data["base_url"]
-            if "is_reasoning" in model_data:
-                model["is_reasoning"] = model_data["is_reasoning"]
-            if "input_price" in model_data:
-                model["input_price"] = float(model_data["input_price"])
-            if "output_price" in model_data:
-                model["output_price"] = float(model_data["output_price"])
-            if "max_output_tokens" in model_data:
-                model["max_output_tokens"] = int(model_data["max_output_tokens"])
-            if "average_speed" in model_data:
-                model["average_speed"] = float(model_data["average_speed"])
-            
-            # 保存更新后的模型
-            models[i] = model
-            found = True
-            
-            # 如果提供了API密钥，则更新
-            if "api_key" in model_data and model_data["api_key"]:
-                update_model_with_api_key(name, model_data["api_key"])
-            
-            break
+    # Filter out fields that don't exist in the new schema
+    filtered_data = {k: v for k, v in model_data.items() if k != "average_speed"}
+    
+    updated_model = lm.update_model(name, filtered_data)
     
-    if found:
-        save_models(models)
-        return models[i]
+    if updated_model:
+        return _model_to_dict(updated_model)
     
     return None
 
+# Backward compatibility: preserve the default_models_list for any external usage
+default_models_list = load_models()
+

autocoder/plugins/git_helper_plugin.py

@@ -8,6 +8,7 @@ import subprocess
 from typing import Any, Callable, Dict, List, Optional, Tuple
 
 from autocoder.plugins import Plugin, PluginManager
+from autocoder.common.international import register_messages, get_message, get_message_with_format
 
 
 class GitHelperPlugin(Plugin):
@@ -19,7 +20,8 @@ class GitHelperPlugin(Plugin):
 
     def __init__(self, manager: PluginManager, config: Optional[Dict[str, Any]] = None, config_path: Optional[str] = None):
         """Initialize the Git helper plugin."""
-        super().__init__(manager, config, config_path)
+        super().__init__(manager, config, config_path)        
+        
         self.git_available = self._check_git_available()
         self.default_branch = self.config.get("default_branch", "main")
 
@@ -43,10 +45,10 @@ class GitHelperPlugin(Plugin):
             True if initialization was successful
         """
         if not self.git_available:
-            print(f"[{self.name}] 警告: Git不可用，某些功能受限")
+            print(f"[{self.name}] {get_message('git_not_available_warning')}")
             return True
 
-        print(f"[{self.name}] Git助手插件已初始化")
+        print(f"[{self.name}] {get_message('git_helper_initialized')}")
         return True
 
     def get_commands(self) -> Dict[str, Tuple[Callable, str]]:
@@ -56,15 +58,15 @@ class GitHelperPlugin(Plugin):
             A dictionary of command name to handler and description
         """
         return {
-            "git/status": (self.git_status, "显示Git仓库状态"),
-            "git/commit": (self.git_commit, "提交更改"),
-            "git/branch": (self.git_branch, "显示或创建分支"),
-            "git/checkout": (self.git_checkout, "切换分支"),
-            "git/diff": (self.git_diff, "显示更改差异"),
-            "git/log": (self.git_log, "显示提交历史"),
-            "git/pull": (self.git_pull, "拉取远程更改"),
-            "git/push": (self.git_push, "推送本地更改到远程"),
-            "git/reset": (self.handle_reset, "重置当前分支到指定状态 (hard/soft/mixed)"),
+            "git/status": (self.git_status, get_message("cmd_git_status_desc")),
+            "git/commit": (self.git_commit, get_message("cmd_git_commit_desc")),
+            "git/branch": (self.git_branch, get_message("cmd_git_branch_desc")),
+            "git/checkout": (self.git_checkout, get_message("cmd_git_checkout_desc")),
+            "git/diff": (self.git_diff, get_message("cmd_git_diff_desc")),
+            "git/log": (self.git_log, get_message("cmd_git_log_desc")),
+            "git/pull": (self.git_pull, get_message("cmd_git_pull_desc")),
+            "git/push": (self.git_push, get_message("cmd_git_push_desc")),
+            "git/reset": (self.handle_reset, get_message("cmd_git_reset_desc")),
         }
 
     def get_completions(self) -> Dict[str, List[str]]:
@@ -111,7 +113,7 @@ class GitHelperPlugin(Plugin):
             A tuple of (return_code, stdout, stderr)
         """
         if not self.git_available:
-            return 1, "", "Git不可用"
+            return 1, "", get_message("git_not_available")
 
         try:
             process = subprocess.run(
@@ -143,12 +145,12 @@ class GitHelperPlugin(Plugin):
         if code == 0:
             print(f"\n{stdout}")
         else:
-            print(f"Error: {stderr}")
+            print(f"{get_message('error_prefix')} {stderr}")
 
     def git_commit(self, args: str) -> None:
         """Handle the git/commit command."""
         if not args:
-            print("请提供提交信息，例如: /git/commit 'Fix bug in login'")
+            print(get_message("commit_message_required"))
             return
 
         # 首先执行添加所有更改 (git add .)
@@ -159,7 +161,7 @@ class GitHelperPlugin(Plugin):
         if code == 0:
             print(f"\n{stdout}")
         else:
-            print(f"Error: {stderr}")
+            print(f"{get_message('error_prefix')} {stderr}")
 
     def git_branch(self, args: str) -> None:
         """Handle the git/branch command."""
@@ -168,12 +170,12 @@ class GitHelperPlugin(Plugin):
         if code == 0:
             print(f"\n{stdout}")
         else:
-            print(f"Error: {stderr}")
+            print(f"{get_message('error_prefix')} {stderr}")
 
     def git_checkout(self, args: str) -> None:
         """Handle the git/checkout command."""
         if not args:
-            print("请提供分支名称，例如: /git/checkout main")
+            print(get_message("checkout_branch_required"))
             return
 
         args_list = args.split()
@@ -181,7 +183,7 @@ class GitHelperPlugin(Plugin):
         if code == 0:
             print(f"\n{stdout}")
         else:
-            print(f"Error: {stderr}")
+            print(f"{get_message('error_prefix')} {stderr}")
 
     def git_diff(self, args: str) -> None:
         """Handle the git/diff command."""
@@ -191,9 +193,9 @@ class GitHelperPlugin(Plugin):
             if stdout:
                 print(f"\n{stdout}")
             else:
-                print("没有差异")
+                print(get_message("no_differences"))
         else:
-            print(f"Error: {stderr}")
+            print(f"{get_message('error_prefix')} {stderr}")
 
     def git_log(self, args: str) -> None:
         """Handle the git/log command."""
@@ -202,7 +204,7 @@ class GitHelperPlugin(Plugin):
         if code == 0:
             print(f"\n{stdout}")
         else:
-            print(f"Error: {stderr}")
+            print(f"{get_message('error_prefix')} {stderr}")
 
     def git_pull(self, args: str) -> None:
         """Handle the git/pull command."""
@@ -211,7 +213,7 @@ class GitHelperPlugin(Plugin):
         if code == 0:
             print(f"\n{stdout}")
         else:
-            print(f"Error: {stderr}")
+            print(f"{get_message('error_prefix')} {stderr}")
 
     def git_push(self, args: str) -> None:
         """Handle the git/push command."""
@@ -220,7 +222,7 @@ class GitHelperPlugin(Plugin):
         if code == 0:
             print(f"\n{stdout}")
         else:
-            print(f"Error: {stderr}")
+            print(f"{get_message('error_prefix')} {stderr}")
 
     def handle_reset(self, args: str) -> None:
         """Handle the git/reset command.
@@ -229,7 +231,7 @@ class GitHelperPlugin(Plugin):
             args: The reset mode (hard/soft/mixed) and optional commit hash
         """
         if not args:
-            print("请提供重置模式 (hard/soft/mixed) 和可选的提交哈希")
+            print(get_message("reset_mode_required"))
             return
             
         args_list = args.split()
@@ -237,16 +239,16 @@ class GitHelperPlugin(Plugin):
         commit = args_list[1] if len(args_list) > 1 else "HEAD"
         
         if mode not in ["hard", "soft", "mixed"]:
-            print(f"错误: 无效的重置模式 '{mode}'，必须是 hard/soft/mixed 之一")
+            print(get_message_with_format("invalid_reset_mode", mode=mode))
             return
             
         code, stdout, stderr = self._run_git_command(["reset", f"--{mode}", commit])
         if code == 0:
             print(f"\n{stdout}")
-            print(f"成功将仓库重置为 {mode} 模式到 {commit}")
+            print(get_message_with_format("reset_success", mode=mode, commit=commit))
         else:
-            print(f"Error: {stderr}")
+            print(f"{get_message('error_prefix')} {stderr}")
 
     def shutdown(self) -> None:
         """Shutdown the plugin."""
-        print(f"[{self.name}] Git助手插件已关闭")
+        print(f"[{self.name}] {get_message('git_helper_shutdown')}")