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

autocoder/sdk/cli/completion_wrapper.py

@@ -0,0 +1,38 @@
+
+
+#!/usr/bin/env python3
+"""
+Auto-Coder CLI 自动补全包装器
+
+提供一个独立的补全脚本，不依赖于特定的 shell 环境
+"""
+
+import sys
+import os
+
+def main():
+    """主函数，处理自动补全请求"""
+    try:
+        # 设置环境变量以启用 argcomplete
+        os.environ.setdefault('_ARGCOMPLETE_COMPLETE', 'complete')
+        
+        # 导入并运行 CLI
+        from autocoder.sdk.cli.main import AutoCoderCLI
+        
+        # 模拟 auto-coder.run 命令
+        sys.argv[0] = 'auto-coder.run'
+        
+        # 解析参数（这会触发自动补全）
+        AutoCoderCLI.parse_args()
+        
+    except SystemExit:
+        # argcomplete 会调用 sys.exit，这是正常的
+        pass
+    except Exception as e:
+        # 在补全过程中出现错误，静默处理
+        pass
+
+if __name__ == '__main__':
+    main()
+
+

autocoder/sdk/cli/formatters.py

@@ -0,0 +1,211 @@
+"""
+输出格式化器模块
+
+提供不同格式的输出处理，支持文本、JSON和流式JSON格式。
+"""
+
+import json
+import asyncio
+from typing import Any, Dict, AsyncIterator, Union, Optional
+
+
+class OutputFormatter:
+    """输出格式化器，处理不同格式的输出。"""
+    
+    def __init__(self, verbose: bool = False):
+        """
+        初始化输出格式化器。
+        
+        Args:
+            verbose: 是否输出详细信息
+        """
+        self.verbose = verbose
+    
+    def format_text(self, content: Union[str, Dict[str, Any]]) -> str:
+        """
+        格式化为文本输出。
+        
+        Args:
+            content: 要格式化的内容，可以是字符串或字典
+            
+        Returns:
+            格式化后的文本
+        """
+        if isinstance(content, dict):
+            # 如果是字典，提取主要内容
+            if "content" in content:
+                result = content["content"]
+            else:
+                result = str(content)
+        else:
+            result = str(content)
+            
+        if self.verbose:
+            # 在详细模式下添加调试信息
+            debug_info = self._get_debug_info(content)
+            if debug_info:
+                result += f"\n\n[DEBUG]\n{debug_info}"
+                
+        return result
+    
+    def format_json(self, content: Any) -> str:
+        """
+        格式化为JSON输出。
+        
+        Args:
+            content: 要格式化的内容
+            
+        Returns:
+            JSON格式的字符串
+        """
+        # 确保内容可以被序列化为JSON
+        if isinstance(content, str):
+            try:
+                # 尝试解析为JSON
+                parsed = json.loads(content)
+                content = parsed
+            except json.JSONDecodeError:
+                # 如果不是有效的JSON，则包装为字典
+                content = {"content": content}
+        
+        # 添加调试信息（如果启用详细模式）
+        if self.verbose and isinstance(content, dict):
+            content["debug"] = self._get_debug_info_dict(content)
+            
+        return json.dumps(content, ensure_ascii=False, indent=2)
+    
+    async def format_stream_json(self, stream: AsyncIterator[Any]) -> AsyncIterator[str]:
+        """
+        格式化为流式JSON输出。
+        
+        Args:
+            stream: 异步迭代器，提供流式内容
+            
+        Yields:
+            JSON格式的字符串，每行一个JSON对象
+        """
+        async for item in stream:
+            # 处理不同类型的项
+            if isinstance(item, dict):
+                output = item
+            elif isinstance(item, str):
+                try:
+                    output = json.loads(item)
+                except json.JSONDecodeError:
+                    output = {"content": item, "type": "text"}
+            else:
+                output = {"content": str(item), "type": "text"}
+            
+            # 添加调试信息（如果启用详细模式）
+            if self.verbose:
+                output["debug"] = self._get_debug_info_dict(output)
+                
+            yield json.dumps(output, ensure_ascii=False)
+    
+    def _get_debug_info(self, content: Any) -> str:
+        """
+        获取调试信息的文本表示。
+        
+        Args:
+            content: 内容对象
+            
+        Returns:
+            调试信息文本
+        """
+        debug_dict = self._get_debug_info_dict(content)
+        if debug_dict:
+            return json.dumps(debug_dict, ensure_ascii=False, indent=2)
+        return ""
+    
+    def _get_debug_info_dict(self, content: Any) -> Dict[str, Any]:
+        """
+        获取调试信息的字典表示。
+        
+        Args:
+            content: 内容对象
+            
+        Returns:
+            调试信息字典
+        """
+        debug_info = {}
+        
+        # 从内容中提取元数据
+        if isinstance(content, dict):
+            if "metadata" in content:
+                debug_info["metadata"] = content["metadata"]
+            
+            # 提取令牌计数信息
+            if "tokens" in content:
+                debug_info["tokens"] = content["tokens"]
+            elif "metadata" in content and "tokens" in content["metadata"]:
+                debug_info["tokens"] = content["metadata"]["tokens"]
+                
+            # 提取模型信息
+            if "model" in content:
+                debug_info["model"] = content["model"]
+            elif "metadata" in content and "model" in content["metadata"]:
+                debug_info["model"] = content["metadata"]["model"]
+                
+            # 提取时间信息
+            if "timestamp" in content:
+                debug_info["timestamp"] = content["timestamp"]
+            elif "metadata" in content and "timestamp" in content["metadata"]:
+                debug_info["timestamp"] = content["metadata"]["timestamp"]
+        
+        return debug_info
+
+
+class InputFormatter:
+    """输入格式化器，处理不同格式的输入。"""
+    
+    def format_text(self, content: str) -> str:
+        """
+        格式化文本输入。
+        
+        Args:
+            content: 输入文本
+            
+        Returns:
+            格式化后的文本
+        """
+        return content.strip()
+    
+    def format_json(self, content: str) -> Dict[str, Any]:
+        """
+        格式化JSON输入。
+        
+        Args:
+            content: JSON格式的输入字符串
+            
+        Returns:
+            解析后的字典
+            
+        Raises:
+            ValueError: 如果输入不是有效的JSON
+        """
+        try:
+            return json.loads(content)
+        except json.JSONDecodeError as e:
+            raise ValueError(f"无效的JSON输入: {str(e)}")
+    
+    async def format_stream_json(self, content: str) -> AsyncIterator[Dict[str, Any]]:
+        """
+        格式化流式JSON输入。
+        
+        Args:
+            content: 包含多行JSON对象的字符串
+            
+        Yields:
+            解析后的字典
+            
+        Raises:
+            ValueError: 如果某行不是有效的JSON
+        """
+        for line in content.strip().split("\n"):
+            if not line.strip():
+                continue
+                
+            try:
+                yield json.loads(line)
+            except json.JSONDecodeError as e:
+                raise ValueError(f"无效的JSON行: {line}, 错误: {str(e)}")

autocoder/sdk/cli/handlers.py

@@ -0,0 +1,174 @@
+"""
+命令处理器模块
+
+提供统一的命令处理器，支持单次运行和会话复用功能。
+"""
+
+import sys
+import asyncio
+from pathlib import Path
+from typing import Optional, Dict, Any, List, Union
+
+from ..core import AutoCoderCore
+from ..models import AutoCodeOptions, Message
+from ..exceptions import AutoCoderSDKError
+from .options import CLIOptions, CLIResult
+from .formatters import OutputFormatter, InputFormatter
+
+
+class CommandHandler:
+    """命令处理器基类，提供通用功能。"""
+    
+    def __init__(self, options: CLIOptions, cwd: Optional[str] = None):
+        """
+        初始化命令处理器。
+        
+        Args:
+            options: CLI选项
+            cwd: 当前工作目录，如果为None则使用系统当前目录
+        """
+        self.options = options
+        self.cwd = Path(cwd) if cwd else Path.cwd()
+        self.output_formatter = OutputFormatter(verbose=options.verbose)
+        self.input_formatter = InputFormatter()
+        
+    def _create_core_options(self) -> AutoCodeOptions:
+        """
+        创建核心选项。
+        
+        Returns:
+            AutoCodeOptions实例
+        """
+        return AutoCodeOptions(
+            max_turns=self.options.max_turns,
+            system_prompt=self.options.system_prompt,
+            cwd=str(self.cwd),
+            allowed_tools=self.options.allowed_tools,
+            permission_mode=self.options.permission_mode,
+            output_format=self.options.output_format,
+            stream=self.options.output_format.startswith("stream"),
+            session_id=self.options.resume_session,
+            continue_session=self.options.continue_session,
+            model=self.options.model
+        )
+        
+    def _get_prompt(self) -> str:
+        """
+        获取提示内容，如果未提供则从stdin读取。
+        
+        Returns:
+            提示内容
+            
+        Raises:
+            ValueError: 如果未提供提示且stdin为空
+        """
+        if self.options.prompt:
+            return self.options.prompt
+            
+        # 从stdin读取
+        if not sys.stdin.isatty():
+            content = sys.stdin.read()
+            if not content.strip():
+                raise ValueError("未提供提示内容且标准输入为空")
+                
+            # 根据输入格式处理
+            if self.options.input_format == "text":
+                return self.input_formatter.format_text(content)
+            elif self.options.input_format == "json":
+                result = self.input_formatter.format_json(content)
+                # 尝试提取提示内容
+                if isinstance(result, dict):
+                    if "prompt" in result:
+                        return result["prompt"]
+                    elif "message" in result:
+                        message = result["message"]
+                        if isinstance(message, dict) and "content" in message:
+                            return message["content"]
+                        elif isinstance(message, str):
+                            return message
+                return content  # 如果无法提取，则返回原始内容
+            else:
+                # 对于流式输入，暂时只支持直接传递
+                return content
+        else:
+            raise ValueError("未提供提示内容且没有标准输入")
+
+
+class PrintModeHandler(CommandHandler):
+    """统一的命令处理器，支持单次运行和会话复用。"""
+    
+    def handle(self) -> CLIResult:
+        """
+        处理命令，支持会话复用。
+        
+        Returns:
+            命令执行结果
+        """
+        try:
+            prompt = self._get_prompt()
+            core_options = self._create_core_options()
+            core = AutoCoderCore(core_options)
+
+            # 根据会话参数构建完整的 prompt
+            final_prompt = self._build_prompt_with_session_context(prompt)
+            
+            # 根据输出格式选择不同的处理方式
+            if self.options.output_format == "stream-json":
+                # 流式JSON输出
+                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)
+                    
+            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。
+        
+        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)
+
+