auto-coder 0.1.398__py3-none-any.whl → 0.1.400__py3-none-any.whl

autocoder/sdk/cli/install_completion.py

@@ -0,0 +1,301 @@
+
+#!/usr/bin/env python3
+"""
+Auto-Coder CLI 自动补全安装脚本
+
+该脚本帮助用户在不同的 shell 环境中安装 auto-coder.run 命令的自动补全功能。
+"""
+
+import os
+import sys
+import subprocess
+from pathlib import Path
+from typing import Optional
+
+
+class CompletionInstaller:
+    """自动补全安装器"""
+    
+    def __init__(self):
+        self.shell = self._detect_shell()
+        self.home_dir = Path.home()
+        
+    def _detect_shell(self) -> str:
+        """检测当前使用的 shell"""
+        shell = os.environ.get('SHELL', '')
+        if 'bash' in shell:
+            return 'bash'
+        elif 'zsh' in shell:
+            return 'zsh'
+        elif 'fish' in shell:
+            return 'fish'
+        else:
+            return 'unknown'
+    
+    def _get_completion_script(self, shell: str) -> str:
+        """获取对应 shell 的补全脚本"""
+        # 获取当前 Python 环境的路径
+        python_path = sys.executable
+        register_cmd_path = os.path.join(os.path.dirname(python_path), 'register-python-argcomplete')
+        
+        # 检查 register-python-argcomplete 是否存在
+        if not os.path.exists(register_cmd_path):
+            # 如果不存在，提供一个简化的解决方案
+            return self._get_simple_completion_script(shell)
+        
+        if shell == 'bash':
+            return f'''# Auto-Coder CLI 自动补全
+eval "$({register_cmd_path} auto-coder.run 2>/dev/null || echo '')"'''
+        elif shell == 'zsh':
+            return f'''# Auto-Coder CLI 自动补全
+# 检查是否在 zsh 环境中
+if [[ -n "$ZSH_VERSION" ]]; then
+    autoload -U +X bashcompinit && bashcompinit 2>/dev/null
+fi
+eval "$({register_cmd_path} auto-coder.run 2>/dev/null || echo '')"'''
+        elif shell == 'fish':
+            return f'''# Auto-Coder CLI 自动补全
+{register_cmd_path} --shell fish auto-coder.run 2>/dev/null | source'''
+        else:
+            return ''
+    
+    def _get_simple_completion_script(self, shell: str) -> str:
+        """获取简化的补全脚本（当 register-python-argcomplete 不可用时）"""
+        python_path = sys.executable
+        
+        if shell in ['bash', 'zsh']:
+            return f'''# Auto-Coder CLI 自动补全（简化版本）
+# 注意：需要安装 argcomplete 包才能使用完整功能
+_auto_coder_run_completion() {{
+    local cur prev opts
+    COMPREPLY=()
+    cur="${{COMP_WORDS[COMP_CWORD]}}"
+    prev="${{COMP_WORDS[COMP_CWORD-1]}}"
+    
+    opts="-h --help -p --print -c --continue -r --resume --output-format --input-format -v --verbose --max-turns --system-prompt --allowed-tools --permission-mode"
+    
+    case "${{prev}}" in
+        --allowed-tools)
+            COMPREPLY=( $(compgen -W "execute_command read_file write_to_file replace_in_file search_files list_files list_code_definition_names ask_followup_question attempt_completion list_package_info mcp_tool rag_tool" -- ${{cur}}) )
+            return 0
+            ;;
+        --output-format|--input-format)
+            COMPREPLY=( $(compgen -W "text json stream-json" -- ${{cur}}) )
+            return 0
+            ;;
+        --permission-mode)
+            COMPREPLY=( $(compgen -W "manual acceptEdits" -- ${{cur}}) )
+            return 0
+            ;;
+    esac
+    
+    COMPREPLY=( $(compgen -W "${{opts}}" -- ${{cur}}) )
+}}
+complete -F _auto_coder_run_completion auto-coder.run'''
+        else:
+            return ''
+    
+    def _get_config_file(self, shell: str) -> Optional[Path]:
+        """获取对应 shell 的配置文件路径"""
+        if shell == 'bash':
+            # 按优先级检查 bash 配置文件
+            candidates = ['.bashrc', '.bash_profile', '.profile']
+            for candidate in candidates:
+                config_file = self.home_dir / candidate
+                if config_file.exists():
+                    return config_file
+            # 如果都不存在，默认使用 .bashrc
+            return self.home_dir / '.bashrc'
+        elif shell == 'zsh':
+            return self.home_dir / '.zshrc'
+        elif shell == 'fish':
+            config_dir = self.home_dir / '.config' / 'fish'
+            config_dir.mkdir(parents=True, exist_ok=True)
+            return config_dir / 'config.fish'
+        else:
+            return None
+    
+    def check_argcomplete_installed(self) -> bool:
+        """检查 argcomplete 是否已安装"""
+        try:
+            import argcomplete
+            return True
+        except ImportError:
+            return False
+    
+    def check_register_command_available(self) -> bool:
+        """检查 register-python-argcomplete 命令是否可用"""
+        try:
+            result = subprocess.run(['register-python-argcomplete', '--help'], 
+                                  capture_output=True, text=True)
+            return result.returncode == 0
+        except FileNotFoundError:
+            return False
+    
+    def install_completion(self, force: bool = False) -> bool:
+        """安装自动补全功能"""
+        print(f"检测到的 shell: {self.shell}")
+        
+        # 检查依赖
+        if not self.check_argcomplete_installed():
+            print("错误: argcomplete 包未安装")
+            print("请运行: pip install argcomplete")
+            return False
+        
+        if not self.check_register_command_available():
+            print("错误: register-python-argcomplete 命令不可用")
+            print("请确保 argcomplete 正确安装并在 PATH 中")
+            return False
+        
+        if self.shell == 'unknown':
+            print("错误: 无法检测到支持的 shell")
+            print("支持的 shell: bash, zsh, fish")
+            return False
+        
+        config_file = self._get_config_file(self.shell)
+        if not config_file:
+            print(f"错误: 无法确定 {self.shell} 的配置文件")
+            return False
+        
+        completion_script = self._get_completion_script(self.shell)
+        if not completion_script:
+            print(f"错误: 不支持的 shell: {self.shell}")
+            return False
+        
+        # 检查是否已经安装
+        if config_file.exists():
+            content = config_file.read_text()
+            if 'auto-coder.run' in content and not force:
+                print(f"自动补全似乎已经安装在 {config_file}")
+                print("使用 --force 参数强制重新安装")
+                return True
+        
+        # 添加补全脚本到配置文件
+        try:
+            with open(config_file, 'a') as f:
+                f.write(f'\n# Auto-Coder CLI 自动补全\n')
+                f.write(f'{completion_script}\n')
+            
+            print(f"✓ 自动补全已安装到 {config_file}")
+            print(f"请重新加载 shell 配置或运行: source {config_file}")
+            return True
+            
+        except Exception as e:
+            print(f"错误: 无法写入配置文件 {config_file}: {e}")
+            return False
+    
+    def uninstall_completion(self) -> bool:
+        """卸载自动补全功能"""
+        config_file = self._get_config_file(self.shell)
+        if not config_file or not config_file.exists():
+            print("未找到配置文件或自动补全未安装")
+            return True
+        
+        try:
+            lines = config_file.read_text().splitlines()
+            new_lines = []
+            skip_next = False
+            
+            for line in lines:
+                if '# Auto-Coder CLI 自动补全' in line:
+                    skip_next = True
+                    continue
+                elif skip_next and 'auto-coder.run' in line:
+                    skip_next = False
+                    continue
+                else:
+                    skip_next = False
+                    new_lines.append(line)
+            
+            config_file.write_text('\n'.join(new_lines))
+            print(f"✓ 自动补全已从 {config_file} 中移除")
+            return True
+            
+        except Exception as e:
+            print(f"错误: 无法修改配置文件 {config_file}: {e}")
+            return False
+    
+    def test_completion(self) -> bool:
+        """测试自动补全是否工作"""
+        print("测试自动补全功能...")
+        try:
+            # 尝试获取补全建议
+            result = subprocess.run([
+                'python', '-c', 
+                'import argcomplete; from autocoder.sdk.cli.main import AutoCoderCLI; '
+                'parser = AutoCoderCLI.parse_args.__func__(AutoCoderCLI, []); '
+                'print("自动补全功能正常")'
+            ], capture_output=True, text=True, timeout=5)
+            
+            if result.returncode == 0:
+                print("✓ 自动补全功能测试通过")
+                return True
+            else:
+                print(f"✗ 自动补全功能测试失败: {result.stderr}")
+                return False
+                
+        except Exception as e:
+            print(f"✗ 自动补全功能测试失败: {e}")
+            return False
+
+
+def main():
+    """主函数"""
+    import argparse
+    
+    parser = argparse.ArgumentParser(
+        description="Auto-Coder CLI 自动补全安装工具",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+使用示例:
+  # 安装自动补全
+  python -m autocoder.sdk.cli.install_completion install
+  
+  # 强制重新安装
+  python -m autocoder.sdk.cli.install_completion install --force
+  
+  # 卸载自动补全
+  python -m autocoder.sdk.cli.install_completion uninstall
+  
+  # 测试自动补全
+  python -m autocoder.sdk.cli.install_completion test
+"""
+    )
+    
+    subparsers = parser.add_subparsers(dest='command', help='可用命令')
+    
+    # 安装命令
+    install_parser = subparsers.add_parser('install', help='安装自动补全')
+    install_parser.add_argument('--force', action='store_true', help='强制重新安装')
+    
+    # 卸载命令
+    subparsers.add_parser('uninstall', help='卸载自动补全')
+    
+    # 测试命令
+    subparsers.add_parser('test', help='测试自动补全功能')
+    
+    args = parser.parse_args()
+    
+    if not args.command:
+        parser.print_help()
+        return 1
+    
+    installer = CompletionInstaller()
+    
+    if args.command == 'install':
+        success = installer.install_completion(force=args.force)
+        return 0 if success else 1
+    elif args.command == 'uninstall':
+        success = installer.uninstall_completion()
+        return 0 if success else 1
+    elif args.command == 'test':
+        success = installer.test_completion()
+        return 0 if success else 1
+    else:
+        parser.print_help()
+        return 1
+
+
+if __name__ == '__main__':
+    sys.exit(main())
+

autocoder/sdk/cli/main.py

@@ -0,0 +1,286 @@
+"""
+CLI 主入口点模块
+
+提供命令行接口的主要实现，处理参数解析和命令执行。
+"""
+
+import sys
+import argparse
+from pathlib import Path
+from typing import Optional, List, Dict, Any, Union
+
+try:
+    import argcomplete
+    ARGCOMPLETE_AVAILABLE = True
+except ImportError:
+    ARGCOMPLETE_AVAILABLE = False
+
+from .options import CLIOptions, CLIResult
+from .handlers import PrintModeHandler
+from ..exceptions import AutoCoderSDKError
+
+
+class AutoCoderCLI:
+    """命令行接口主类，处理命令行参数和执行相应的操作。"""
+    
+    def __init__(self):
+        """初始化CLI实例。"""
+        pass
+        
+    def run(self, options: CLIOptions, cwd: Optional[str] = None) -> CLIResult:
+        """
+        运行CLI命令 - 统一使用 Print Mode。
+        
+        Args:
+            options: CLI选项
+            cwd: 当前工作目录，如果为None则使用系统当前目录
+            
+        Returns:
+            命令执行结果
+        """
+        try:
+            # 验证选项
+            options.validate()
+            
+            # 移除模式判断，直接使用 PrintModeHandler
+            return self.handle_print_mode(options, cwd)
+                
+        except Exception as e:
+            return CLIResult(success=False, error=str(e))
+            
+    def handle_print_mode(self, options: CLIOptions, cwd: Optional[str] = None) -> CLIResult:
+        """
+        处理打印模式。
+        
+        Args:
+            options: CLI选项
+            cwd: 当前工作目录
+            
+        Returns:
+            命令执行结果
+        """
+        handler = PrintModeHandler(options, cwd)
+        return handler.handle()
+        
+        
+    @classmethod
+    def parse_args(cls, args: Optional[List[str]] = None) -> CLIOptions:
+        """
+        解析命令行参数。
+        
+        Args:
+            args: 命令行参数列表，如果为None则使用sys.argv
+            
+        Returns:
+            解析后的CLI选项
+        """
+        parser = argparse.ArgumentParser(
+            description="Auto-Coder 命令行工具",
+            formatter_class=argparse.RawDescriptionHelpFormatter,
+            epilog="""
+示例:
+  # 基本使用
+  auto-coder.run "Write a function to calculate Fibonacci numbers" --model gpt-4
+  
+  # 通过管道提供输入
+  echo "Explain this code" | auto-coder.run --model gpt-4
+  
+  # 指定输出格式
+  auto-coder.run "Generate a hello world function" --output-format json --model gpt-4
+  
+  # 继续最近的对话
+  auto-coder.run --continue "继续修改代码" --model gpt-4
+  
+  # 恢复特定会话
+  auto-coder.run --resume 550e8400-e29b-41d4-a716-446655440000 "新的请求" --model gpt-4
+  
+  # 组合使用多个选项
+  auto-coder.run "Optimize this code" --model claude-3-sonnet --max-turns 5 --verbose
+"""
+        )
+        
+        # 会话选项（移除模式选择，--continue 和 --resume 作为独立参数）
+        parser.add_argument("-c", "--continue", dest="continue_session", action="store_true",
+                           help="继续最近的对话")
+        parser.add_argument("-r", "--resume", dest="resume_session", metavar="SESSION_ID",
+                           help="恢复特定会话")
+        
+        # 输入输出选项
+        parser.add_argument("prompt", nargs="?", help="提示内容，如果未提供则从stdin读取")
+        parser.add_argument("--output-format", choices=["text", "json", "stream-json"],
+                          default="text", help="输出格式 (默认: text)")
+        parser.add_argument("--input-format", choices=["text", "json", "stream-json"],
+                          default="text", help="输入格式 (默认: text)")
+        parser.add_argument("-v", "--verbose", action="store_true", help="输出详细信息")
+        
+        # 高级选项
+        advanced = parser.add_argument_group("高级选项")
+        advanced.add_argument("--max-turns", type=int, default= -1, help="最大对话轮数 (默认: -1 不限制)")
+        advanced.add_argument("--system-prompt", help="系统提示")
+        advanced.add_argument("--allowed-tools", nargs="+", help="允许使用的工具列表")
+        advanced.add_argument("--permission-mode", choices=["manual", "acceptEdits"],
+                           default="manual", help="权限模式 (默认: manual)")
+        advanced.add_argument("--model", required=True, help="指定使用的模型名称 (如: gpt-4, gpt-3.5-turbo, claude-3-sonnet 等)")
+        advanced.add_argument("--pr", action="store_true", help="创建 Pull Request")
+        
+        # 启用自动补全
+        if ARGCOMPLETE_AVAILABLE:
+            # 添加自定义补全器
+            cls._setup_completers(parser)
+            argcomplete.autocomplete(parser)
+        
+        # 解析参数
+        parsed_args = parser.parse_args(args)
+        
+        # 转换为CLIOptions
+        options = CLIOptions(
+            continue_session=parsed_args.continue_session,
+            resume_session=parsed_args.resume_session,
+            prompt=parsed_args.prompt,
+            output_format=parsed_args.output_format,
+            input_format=parsed_args.input_format,
+            verbose=parsed_args.verbose,
+            max_turns=parsed_args.max_turns,
+            system_prompt=parsed_args.system_prompt,
+            allowed_tools=parsed_args.allowed_tools or [],
+            permission_mode=parsed_args.permission_mode,
+            model=parsed_args.model,
+            pr=parsed_args.pr
+        )
+        
+        return options
+    
+    @classmethod
+    def _setup_completers(cls, parser: argparse.ArgumentParser) -> None:
+        """设置自定义补全器"""
+        if not ARGCOMPLETE_AVAILABLE:
+            return
+            
+        # 为 --allowed-tools 参数设置补全器
+        def tools_completer(prefix, parsed_args, **kwargs):
+            """工具名称补全器"""
+            available_tools = [
+                "execute_command",
+                "read_file", 
+                "write_to_file",
+                "replace_in_file",
+                "search_files",
+                "list_files",
+                "list_code_definition_names",
+                "ask_followup_question",
+                "attempt_completion",
+                "list_package_info",
+                "mcp_tool",
+                "rag_tool"
+            ]
+            return [tool for tool in available_tools if tool.startswith(prefix)]
+        
+        # 为 --resume 参数设置会话ID补全器
+        def session_id_completer(prefix, parsed_args, **kwargs):
+            """会话ID补全器"""
+            try:
+                # 这里可以从会话存储中获取可用的会话ID
+                # 目前返回示例会话ID格式
+                return [
+                    "550e8400-e29b-41d4-a716-446655440000",
+                    "6ba7b810-9dad-11d1-80b4-00c04fd430c8",
+                    "6ba7b811-9dad-11d1-80b4-00c04fd430c8"
+                ]
+            except Exception:
+                return []
+        
+        # 为 prompt 参数设置示例补全器
+        def prompt_completer(prefix, parsed_args, **kwargs):
+            """提示内容补全器"""
+            common_prompts = [
+                "Write a function to calculate Fibonacci numbers",
+                "Explain this code",
+                "Generate a hello world function",
+                "Create a simple web page",
+                "Write unit tests for this code",
+                "Refactor this function",
+                "Add error handling",
+                "Optimize this algorithm",
+                "Document this code",
+                "Fix the bug in this code"
+            ]
+            return [prompt for prompt in common_prompts if prompt.lower().startswith(prefix.lower())]
+        
+        # 为 --model 参数设置模型名称补全器
+        def model_completer(prefix, parsed_args, **kwargs):
+            """模型名称补全器"""
+            common_models = [
+                # OpenAI models
+                "gpt-4",
+                "gpt-4-turbo",
+                "gpt-4-turbo-preview",
+                "gpt-4-0125-preview",
+                "gpt-4-1106-preview",
+                "gpt-3.5-turbo",
+                "gpt-3.5-turbo-16k",
+                "gpt-3.5-turbo-1106",
+                # Anthropic models
+                "claude-3-opus",
+                "claude-3-sonnet",
+                "claude-3-haiku",
+                "claude-2.1",
+                "claude-2.0",
+                "claude-instant-1.2",
+                # Google models
+                "gemini-pro",
+                "gemini-pro-vision",
+                # Local/Open source models
+                "llama2-7b",
+                "llama2-13b",
+                "llama2-70b",
+                "codellama-7b",
+                "codellama-13b",
+                "codellama-34b",
+                "mistral-7b",
+                "mixtral-8x7b",
+                # Azure OpenAI
+                "azure-gpt-4",
+                "azure-gpt-35-turbo",
+            ]
+            return [model for model in common_models if model.lower().startswith(prefix.lower())]
+        
+        # 应用补全器到对应的参数
+        for action in parser._actions:
+            if hasattr(action, 'dest'):
+                if action.dest == 'allowed_tools':
+                    action.completer = tools_completer
+                elif action.dest == 'resume_session':
+                    action.completer = session_id_completer
+                elif action.dest == 'prompt':
+                    action.completer = prompt_completer
+                elif action.dest == 'model':
+                    action.completer = model_completer
+        
+    @classmethod
+    def main(cls) -> int:
+        """
+        CLI主入口点。
+        
+        Returns:
+            退出码，0表示成功，非0表示失败
+        """
+        try:
+            options = cls.parse_args()
+            cli = cls()
+            result = cli.run(options)
+            
+            if result.success:
+                if result.output:
+                    print(result.output)
+                return 0
+            else:
+                print(f"错误: {result.error}", file=sys.stderr)
+                return 1
+                
+        except Exception as e:
+            print(f"未处理的错误: {str(e)}", file=sys.stderr)
+            return 1
+
+
+if __name__ == "__main__":
+    sys.exit(AutoCoderCLI.main())

autocoder/sdk/cli/options.py

@@ -0,0 +1,73 @@
+"""
+CLI 选项定义模块
+
+定义命令行接口的选项和结果数据结构。
+"""
+
+from dataclasses import dataclass, field
+from typing import Optional, Dict, Any
+
+from ..constants import DEFAULT_MODEL
+
+
+@dataclass
+class CLIOptions:
+    """CLI选项数据类，用于配置命令行工具的行为。"""
+    
+    # 会话选项
+    continue_session: bool = False  # 继续最近的对话
+    resume_session: Optional[str] = None  # 恢复特定会话的ID
+    
+    # 输入选项
+    prompt: Optional[str] = None  # 提示内容，如果为None则从stdin读取
+    input_format: str = "text"  # 输入格式，可选值: text, json, stream-json
+    
+    # 输出选项
+    output_format: str = "text"  # 输出格式，可选值: text, json, stream-json
+    verbose: bool = False  # 是否输出详细信息
+    
+    # 高级选项
+    max_turns: int = 3  # 最大对话轮数
+    system_prompt: Optional[str] = None  # 系统提示
+    allowed_tools: list = field(default_factory=list)  # 允许使用的工具列表
+    permission_mode: str = "manual"  # 权限模式，可选值: manual, acceptEdits
+    model: Optional[str] = None  # 模型名称，如 gpt-4, gpt-3.5-turbo 等
+    pr: bool = False  # 是否创建 PR
+    
+    def validate(self) -> None:
+        """验证选项的有效性。"""
+        # 验证输出格式
+        valid_formats = ["text", "json", "stream-json"]
+        if self.output_format not in valid_formats:
+            raise ValueError(f"无效的输出格式: {self.output_format}，有效值为: {', '.join(valid_formats)}")
+        
+        # 验证输入格式
+        if self.input_format not in valid_formats:
+            raise ValueError(f"无效的输入格式: {self.input_format}，有效值为: {', '.join(valid_formats)}")
+        
+        # 验证权限模式
+        valid_permission_modes = ["manual", "acceptEdits"]
+        if self.permission_mode not in valid_permission_modes:
+            raise ValueError(f"无效的权限模式: {self.permission_mode}，有效值为: {', '.join(valid_permission_modes)}")
+        
+        # 验证最大对话轮数（-1表示不限制）
+        if self.max_turns <= 0 and self.max_turns != -1:
+            raise ValueError("max_turns必须为正数或-1（表示不限制）")
+        
+        # 验证会话选项的互斥性
+        if self.continue_session and self.resume_session:
+            raise ValueError("continue_session和resume_session不能同时设置")
+        
+        # 验证模型参数必须存在
+        if not self.model or not self.model.strip():
+            raise ValueError("model参数是必需的，请使用 --model 参数指定要使用的模型")
+
+
+@dataclass
+class CLIResult:
+    """CLI执行结果数据类，用于返回命令执行的结果。"""
+    
+    success: bool  # 是否成功执行
+    output: str = ""  # 输出内容
+    error: Optional[str] = None  # 错误信息
+    debug_info: Optional[Dict[str, Any]] = None  # 调试信息