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

autocoder/sdk/cli/handlers.py

@@ -10,10 +10,13 @@ from pathlib import Path
 from typing import Optional, Dict, Any, List, Union
 
 from ..core import AutoCoderCore
-from ..models import AutoCodeOptions, Message
+from ..models import AutoCodeOptions
+from ..models.responses import CLIResult  # 从正确的位置导入
 from ..exceptions import AutoCoderSDKError
-from .options import CLIOptions, CLIResult
-from .formatters import OutputFormatter, InputFormatter
+from .options import CLIOptions
+from ..formatters import OutputFormatter, InputFormatter, format_stream_output  # 使用新的 formatters 模块
+from autocoder.common.international import get_message
+from autocoder.common.llm_friendly_package import get_package_manager
 
 
 class CommandHandler:
@@ -39,9 +42,18 @@ class CommandHandler:
         Returns:
             AutoCodeOptions实例
         """
+        # 处理 system_prompt 和 system_prompt_path
+        system_prompt = self.options.system_prompt
+        if self.options.system_prompt_path:
+            try:
+                with open(self.options.system_prompt_path, 'r', encoding='utf-8') as f:
+                    system_prompt = f.read().strip()
+            except Exception as e:
+                raise ValueError(f"无法读取系统提示文件 {self.options.system_prompt_path}: {str(e)}")
+        
         return AutoCodeOptions(
             max_turns=self.options.max_turns,
-            system_prompt=self.options.system_prompt,
+            system_prompt=system_prompt,
             cwd=str(self.cwd),
             allowed_tools=self.options.allowed_tools,
             permission_mode=self.options.permission_mode,
@@ -50,7 +62,14 @@ class CommandHandler:
             session_id=self.options.resume_session,
             continue_session=self.options.continue_session,
             model=self.options.model,
-            pr=self.options.pr
+            verbose=self.options.verbose,
+            include_rules=self.options.include_rules,
+            pr=self.options.pr,
+            is_sub_agent=self.options.is_sub_agent,
+            loop=self.options.loop,
+            loop_keep_conversation=self.options.loop_keep_conversation,
+            loop_additional_prompt=self.options.loop_additional_prompt,
+            include_libs=self.options.include_libs
         )
         
     def _get_prompt(self) -> str:
@@ -70,7 +89,7 @@ class CommandHandler:
         if not sys.stdin.isatty():
             content = sys.stdin.read()
             if not content.strip():
-                raise ValueError("未提供提示内容且标准输入为空")
+                raise ValueError(get_message("prompt_not_provided_empty_stdin"))
                 
             # 根据输入格式处理
             if self.options.input_format == "text":
@@ -92,7 +111,20 @@ class CommandHandler:
                 # 对于流式输入，暂时只支持直接传递
                 return content
         else:
-            raise ValueError("未提供提示内容且没有标准输入")
+            raise ValueError(get_message("prompt_not_provided_no_stdin"))
+    
+    def _add_libraries(self) -> None:
+        """自动添加指定的 LLM friendly packages"""
+        try:
+            manager = get_package_manager(str(self.cwd))
+            
+            for lib_name in self.options.include_libs:
+                if lib_name.strip():  # 确保库名不为空
+                    manager.add_library(lib_name.strip())
+                            
+        except Exception:
+            # 不抛出异常，只是静默失败，因为这不应该阻止主要功能
+            pass
 
 
 class PrintModeHandler(CommandHandler):
@@ -107,11 +139,16 @@ class PrintModeHandler(CommandHandler):
         """
         try:
             prompt = self._get_prompt()
+            
+            # 自动添加指定的 LLM friendly packages
+            if self.options.include_libs:
+                self._add_libraries()
+                
             core_options = self._create_core_options()
             core = AutoCoderCore(core_options)
 
             # 根据会话参数构建完整的 prompt
-            final_prompt = self._build_prompt_with_session_context(prompt)
+            final_prompt = prompt
             
             # 根据输出格式选择不同的处理方式
             if self.options.output_format == "stream-json":
@@ -119,57 +156,53 @@ class PrintModeHandler(CommandHandler):
                 result = asyncio.run(self._handle_stream(core, final_prompt))
             else:
                 # 同步查询
-                response = core.query_sync(final_prompt)
-                
-                # 格式化输出
                 if self.options.output_format == "json":
-                    result = self.output_formatter.format_json(response)
-                else:
-                    result = self.output_formatter.format_text(response)
+                    # JSON格式：使用事件流方式，禁用终端输出
+                    events = core.query_sync(final_prompt, show_terminal=False)
+                    json_data = {
+                        "events": [event.to_dict() for event in events],
+                        "summary": {
+                            "total_events": len(events),
+                            "start_events": len([e for e in events if e.event_type == "start"]),
+                            "completion_events": len([e for e in events if e.event_type == "completion"]),
+                            "error_events": len([e for e in events if e.event_type == "error"])
+                        }
+                    }
+                    result = self.output_formatter.format_json(json_data)
+                else:                    
+                    events = core.query_sync(final_prompt, show_terminal=self.options.verbose)                                        
+                    completion_content = ""
+                    for event in events:
+                        if event.event_type == "tool_call" and event.data["tool_name"] == "AttemptCompletionTool":
+                            completion_content = event.data["args"]["result"]
+                            break                        
+                                                            
+                    result = self.output_formatter.format_text(completion_content)
                     
             return CLIResult(success=True, output=result)
             
         except Exception as e:
-            return CLIResult(success=False, error=str(e))
-    
-    def _build_prompt_with_session_context(self, prompt: str) -> str:
-        """
-        根据会话参数构建完整的 prompt。
+            return CLIResult(success=False, output="", error=str(e))
         
-        Args:
-            prompt: 原始提示内容
-            
-        Returns:
-            str: 构建后的完整提示
-        """
-        if self.options.continue_session:
-            # 继续当前对话
-            return f"{prompt}" if prompt else ""
-        elif self.options.resume_session:
-            # 恢复特定会话  
-            return f"/resume {self.options.resume_session} {prompt}" if prompt else f"/resume {self.options.resume_session}"
-        else:
-            # 创建新对话
-            return f"/new {prompt}"
             
     async def _handle_stream(self, core: AutoCoderCore, prompt: str) -> str:
         """
-        处理流式输出。
+        处理流式输出，正常打印所有事件。
         
         Args:
             core: AutoCoderCore实例
             prompt: 提示内容
             
         Returns:
-            处理结果
+            空字符串
         """
-        result = []
-        async for message in core.query_stream(prompt):
-            formatted = await anext(self.output_formatter.format_stream_json([message]))
-            result.append(formatted)
-            # 实时输出到stdout
-            print(formatted, flush=True)
-            
-        return "\n".join(result)
+        # 使用 query_stream 方法获取 StreamEvent 流，正常打印所有事件
+        async for event in core.query_stream(prompt, show_terminal=True):
+            # 所有事件都会通过 core.query_stream 的内部渲染机制正常打印
+            # 这里不需要额外的打印逻辑
+            pass
+        
+        # 返回空字符串
+        return ""
 
 

autocoder/sdk/cli/main.py

@@ -3,21 +3,21 @@ CLI 主入口点模块
 
 提供命令行接口的主要实现，处理参数解析和命令执行。
 """
-
 import sys
+import os
 import argparse
-from pathlib import Path
-from typing import Optional, List, Dict, Any, Union
+from typing import Optional, List
+from .options import CLIOptions, get_default_async_workdir
+from ..models.responses import CLIResult
+from .handlers import PrintModeHandler
+from autocoder.run_context import get_run_context,RunMode
+from autocoder.common.international import get_message, get_message_with_format
+from autocoder.common.file_monitor import FileMonitor
+import os
 
-try:
-    import argcomplete
-    ARGCOMPLETE_AVAILABLE = True
-except ImportError:
-    ARGCOMPLETE_AVAILABLE = False
+# 设置运行模式为终端模式
+get_run_context().set_mode(RunMode.CLI)
 
-from .options import CLIOptions, CLIResult
-from .handlers import PrintModeHandler
-from ..exceptions import AutoCoderSDKError
 
 
 class AutoCoderCLI:
@@ -29,7 +29,7 @@ class AutoCoderCLI:
         
     def run(self, options: CLIOptions, cwd: Optional[str] = None) -> CLIResult:
         """
-        运行CLI命令 - 统一使用 Print Mode。
+        运行CLI命令。
         
         Args:
             options: CLI选项
@@ -39,14 +39,57 @@ class AutoCoderCLI:
             命令执行结果
         """
         try:
-            # 验证选项
-            options.validate()
+            # 验证选项            
+            options.validate()            
+            
+            # 根据命令类型分发处理
+            if options.command == "config":
+                return self.handle_config_command(options, cwd)
+            else:
+                # 默认处理代码生成命令
+                return self.handle_print_mode(options, cwd)
+                
+        except Exception as e:
+            return CLIResult(success=False, output="", error=str(e))
+            
+    def handle_config_command(self, options: CLIOptions, cwd: Optional[str] = None) -> CLIResult:
+        """
+        处理 config 命令。
+        
+        Args:
+            options: CLI选项
+            cwd: 当前工作目录
+            
+        Returns:
+            命令执行结果
+        """
+        try:
+            from autocoder.auto_coder_runner import configure
+            
+            if not options.config_args:
+                return CLIResult(success=False, output="", error="配置参数不能为空。用法: auto-coder.run config model=v3_chat")
             
-            # 移除模式判断，直接使用 PrintModeHandler
-            return self.handle_print_mode(options, cwd)
+            # 处理每个配置参数
+            results = []
+            for config_arg in options.config_args:
+                if "=" not in config_arg:
+                    return CLIResult(success=False, output="", error=f"配置参数格式错误: {config_arg}。应使用 key=value 格式")
                 
+                # 将 key=value 转换为 key:value 格式（configure 函数需要的格式）
+                key, value = config_arg.split("=", 1)
+                config_str = f"{key.strip()}:{value.strip()}"
+                
+                try:
+                    configure(config_str, skip_print=True)
+                    results.append(f"✓ 配置成功: {key.strip()} = {value.strip()}")
+                except Exception as e:
+                    return CLIResult(success=False, output="", error=f"配置失败 {config_str}: {str(e)}")
+            
+            output = "\n".join(results)
+            return CLIResult(success=True, output=output)
+            
         except Exception as e:
-            return CLIResult(success=False, error=str(e))
+            return CLIResult(success=False, output="", error=get_message_with_format("config_command_failed", error=str(e)))
             
     def handle_print_mode(self, options: CLIOptions, cwd: Optional[str] = None) -> CLIResult:
         """
@@ -59,8 +102,14 @@ class AutoCoderCLI:
         Returns:
             命令执行结果
         """
-        handler = PrintModeHandler(options, cwd)
-        return handler.handle()
+        # 检查是否启用异步模式        
+        if options.async_mode:
+            from ..async_runner.async_handler import AsyncAgentHandler
+            handler = AsyncAgentHandler(options, cwd)            
+            return handler.handle()
+        else:
+            handler = PrintModeHandler(options, cwd)
+            return handler.handle()
         
         
     @classmethod
@@ -75,65 +124,80 @@ class AutoCoderCLI:
             解析后的CLI选项
         """
         parser = argparse.ArgumentParser(
-            description="Auto-Coder 命令行工具",
+            description=get_message("cli_description"),
             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
-"""
+            epilog=get_message("cli_examples")
         )
         
+        # 创建子命令解析器
+        subparsers = parser.add_subparsers(dest="command", help=get_message("help_available_commands"))
+        
+        # config 子命令
+        config_parser = subparsers.add_parser("config", help=get_message("help_config_command"))
+        config_parser.add_argument("config_args", nargs="*", help=get_message("help_config_args"))
+        
+        # 默认命令（代码生成）- 当没有子命令时使用
         # 会话选项（移除模式选择，--continue 和 --resume 作为独立参数）
         parser.add_argument("-c", "--continue", dest="continue_session", action="store_true",
-                           help="继续最近的对话")
+                           help=get_message("help_continue_session"))
         parser.add_argument("-r", "--resume", dest="resume_session", metavar="SESSION_ID",
-                           help="恢复特定会话")
+                           help=get_message("help_resume_session"))
         
         # 输入输出选项
-        parser.add_argument("prompt", nargs="?", help="提示内容，如果未提供则从stdin读取")
+        parser.add_argument("prompt", nargs="?", help=get_message("help_prompt"))
         parser.add_argument("--output-format", choices=["text", "json", "stream-json"],
-                          default="text", help="输出格式 (默认: text)")
+                          default="text", help=get_message("help_output_format"))
         parser.add_argument("--input-format", choices=["text", "json", "stream-json"],
-                          default="text", help="输入格式 (默认: text)")
-        parser.add_argument("-v", "--verbose", action="store_true", help="输出详细信息")
+                          default="text", help=get_message("help_input_format"))
+        parser.add_argument("-v", "--verbose", action="store_true", help=get_message("help_verbose"))
         
         # 高级选项
-        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 = parser.add_argument_group(get_message("help_advanced_options"))
+        advanced.add_argument("--max-turns", type=int, default= 10000, help=get_message("help_max_turns"))
+        advanced.add_argument("--system-prompt", help=get_message("help_system_prompt"))
+        advanced.add_argument("--system-prompt-path", help=get_message("help_system_prompt_path"))
+        advanced.add_argument("--allowed-tools", nargs="+", help=get_message("help_allowed_tools"))
         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")
+                           default="manual", help=get_message("help_permission_mode"))
+        advanced.add_argument("--model", required=False, help=get_message("help_model"))
+        advanced.add_argument("--include-rules", action="store_true", help=get_message("help_include_rules"))
+        advanced.add_argument("--pr", action="store_true", help=get_message("help_pr"))
+        advanced.add_argument("--is-sub-agent", action="store_true", help=get_message("help_is_sub_agent"))
+        advanced.add_argument("--loop", type=int, default=1, help=get_message("help_loop"))
+        advanced.add_argument("--loop-keep-conversation", dest="loop_keep_conversation", action="store_true", help=get_message("help_loop_keep_conversation"))
+        advanced.add_argument("--loop-additional-prompt", dest="loop_additional_prompt", help=get_message("help_loop_additional_prompt"))
+        advanced.add_argument("--include-libs", dest="include_libs", help=get_message("help_include_libs"))
         
-        # 启用自动补全
-        if ARGCOMPLETE_AVAILABLE:
-            # 添加自定义补全器
-            cls._setup_completers(parser)
-            argcomplete.autocomplete(parser)
+        # 异步代理运行器选项
+        async_group = parser.add_argument_group(get_message("help_async_group_title"))
+        async_group.add_argument("--async", dest="async_mode", action="store_true",
+                               help=get_message("help_async_mode"))
+        async_group.add_argument("--split", dest="split_mode", choices=["h1", "h2", "h3", "any", "delimiter"],
+                               default="h1", help=get_message("help_split_mode"))
+        async_group.add_argument("--delimiter", default="===",
+                               help=get_message("help_delimiter"))
+        async_group.add_argument("--min-level", type=int, default=1,
+                               help=get_message("help_min_level"))
+        async_group.add_argument("--max-level", type=int, default=3,
+                               help=get_message("help_max_level"))
+        async_group.add_argument("--workdir", default=get_default_async_workdir(),
+                               help=get_message("help_workdir"))
+        async_group.add_argument("--from", dest="from_branch", default="",
+                               help=get_message("help_from_branch"))
+        async_group.add_argument("--bg", dest="bg_mode", action="store_true",
+                               help=get_message("help_bg_mode"))
+        async_group.add_argument("--task-prefix", dest="task_prefix", default="",
+                               help=get_message("help_task_prefix"))
+        async_group.add_argument("--worktree-name", dest="worktree_name",
+                               help=get_message("help_worktree_name"))
         
         # 解析参数
         parsed_args = parser.parse_args(args)
         
         # 转换为CLIOptions
         options = CLIOptions(
+            command=getattr(parsed_args, 'command', None),
+            config_args=getattr(parsed_args, 'config_args', []),
             continue_session=parsed_args.continue_session,
             resume_session=parsed_args.resume_session,
             prompt=parsed_args.prompt,
@@ -142,120 +206,32 @@ class AutoCoderCLI:
             verbose=parsed_args.verbose,
             max_turns=parsed_args.max_turns,
             system_prompt=parsed_args.system_prompt,
+            system_prompt_path=getattr(parsed_args, 'system_prompt_path', None),
             allowed_tools=parsed_args.allowed_tools or [],
             permission_mode=parsed_args.permission_mode,
             model=parsed_args.model,
-            pr=parsed_args.pr
+            include_rules=parsed_args.include_rules,
+            pr=parsed_args.pr,
+            is_sub_agent=parsed_args.is_sub_agent,
+            loop=parsed_args.loop,
+            loop_keep_conversation=parsed_args.loop_keep_conversation,
+            loop_additional_prompt=parsed_args.loop_additional_prompt,
+            include_libs=[lib.strip() for lib in parsed_args.include_libs.split(',')] if parsed_args.include_libs else [],
+            # 异步代理运行器相关参数
+            async_mode=parsed_args.async_mode,
+            split_mode=parsed_args.split_mode,
+            delimiter=parsed_args.delimiter,
+            min_level=parsed_args.min_level,
+            max_level=parsed_args.max_level,
+            workdir=parsed_args.workdir,
+            from_branch=parsed_args.from_branch,
+            bg_mode=parsed_args.bg_mode,
+            task_prefix=parsed_args.task_prefix,
+            worktree_name=parsed_args.worktree_name
         )
         
         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:
         """
@@ -263,9 +239,9 @@ class AutoCoderCLI:
         
         Returns:
             退出码，0表示成功，非0表示失败
-        """
-        try:
-            options = cls.parse_args()
+        """        
+        try:            
+            options = cls.parse_args()            
             cli = cls()
             result = cli.run(options)
             
@@ -274,12 +250,24 @@ class AutoCoderCLI:
                     print(result.output)
                 return 0
             else:
-                print(f"错误: {result.error}", file=sys.stderr)
+                print(get_message_with_format("error_prefix", error=result.error), file=sys.stderr)
                 return 1
                 
         except Exception as e:
-            print(f"未处理的错误: {str(e)}", file=sys.stderr)
+            # 如果是 verbose 模式，打印完整的异常堆栈
+            if hasattr(options, 'verbose') and options.verbose:
+                import traceback
+                print(f"[DEBUG] Unhandled exception:", file=sys.stderr)
+                traceback.print_exc(file=sys.stderr)
+            print(get_message_with_format("unhandled_error", error=str(e)), file=sys.stderr)
             return 1
+        
+        finally:            
+            try:
+                FileMonitor(os.getcwd()).stop()
+            except Exception as e:
+                pass
+
 
 
 if __name__ == "__main__":