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

autocoder/rags.py

@@ -369,30 +369,3 @@ def update_rag_status(name: str, status: str, **kwargs) -> bool:
     return rag_manager.update_status(name, status, **kwargs)
 
 
-# 使用示例
-if __name__ == "__main__":
-    # 创建配置
-    config = {
-        "model": "deepseek_chat",
-        "tokenizer_path": "/Users/allwefantasy/Downloads/tokenizer.json",
-        "doc_dir": "/path/to/docs",
-        "rag_doc_filter_relevance": 2.0,
-        "host": "0.0.0.0",
-        "port": 8000,
-        "enable_hybrid_index": False,
-        "required_exts": ".md,.rst",
-        "disable_inference_enhance": True
-    }
-    
-    # 创建
-    create_rag_config("test_rag", config)
-    
-    # 读取
-    all_configs = get_rag_config()
-    specific_config = get_rag_config("test_rag")
-    
-    # 更新
-    update_rag_config("test_rag", {"status": "running", "port": 8001})
-    
-    # 删除
-    delete_rag_config("test_rag")

autocoder/run_context.py

@@ -9,6 +9,7 @@ class RunMode(Enum):
     """Enum representing different run modes for Auto-Coder."""
     TERMINAL = auto()
     WEB = auto()
+    API = auto()
 
 
 class RunContext:

autocoder/sdk/__init__.py

@@ -0,0 +1,188 @@
+"""
+Auto-Coder SDK
+
+为第三方开发者提供的 Python SDK，允许通过命令行工具和 Python API 两种方式使用 Auto-Coder 的核心功能。
+"""
+
+from typing import AsyncIterator, Optional, Dict, Any
+
+from .core.auto_coder_core import AutoCoderCore
+from .models.options import AutoCodeOptions
+from .models.messages import Message
+from .models.responses import StreamEvent, CodeModificationResult
+from .session.session import Session
+from .session.session_manager import SessionManager
+from .exceptions import (
+    AutoCoderSDKError,
+    SessionNotFoundError,
+    InvalidOptionsError,
+    BridgeError,
+    ValidationError
+)
+
+__version__ = "1.0.0"
+__all__ = [
+    # 核心功能
+    "query",
+    "query_sync",
+    "modify_code",
+    "modify_code_stream",
+    
+    # 数据模型
+    "AutoCodeOptions",
+    "Message",
+    "StreamEvent",
+    "CodeModificationResult",
+    
+    # 会话管理
+    "Session",
+    "SessionManager",
+    
+    # 异常
+    "AutoCoderSDKError",
+    "SessionNotFoundError",
+    "InvalidOptionsError",
+    "BridgeError",
+    "ValidationError",
+]
+
+
+async def query(
+    prompt: str, 
+    options: Optional[AutoCodeOptions] = None,
+    show_terminal: bool = True
+) -> AsyncIterator[Message]:
+    """
+    异步流式查询接口
+    
+    Args:
+        prompt: 查询提示
+        options: 配置选项
+        show_terminal: 是否在终端显示友好的渲染输出
+        
+    Yields:
+        Message: 响应消息流
+        
+    Example:
+        >>> import asyncio
+        >>> from autocoder.sdk import query, AutoCodeOptions
+        >>> 
+        >>> async def main():
+        ...     options = AutoCodeOptions(max_turns=3)
+        ...     async for message in query("Write a hello world function", options):
+        ...         print(f"[{message.role}] {message.content}")
+        >>> 
+        >>> asyncio.run(main())
+    """
+    if options is None:
+        options = AutoCodeOptions()
+    core = AutoCoderCore(options)
+    async for message in core.query_stream(f"/new {prompt}", show_terminal):
+        yield message
+
+
+def query_sync(
+    prompt: str, 
+    options: Optional[AutoCodeOptions] = None,
+    show_terminal: bool = True
+) -> str:
+    """
+    同步查询接口
+    
+    Args:
+        prompt: 查询提示
+        options: 配置选项
+        show_terminal: 是否在终端显示友好的渲染输出
+        
+    Returns:
+        str: 响应内容
+        
+    Example:
+        >>> from autocoder.sdk import query_sync, AutoCodeOptions
+        >>> 
+        >>> options = AutoCodeOptions(max_turns=1)
+        >>> response = query_sync("Write a simple calculator function", options)
+        >>> print(response)
+    """
+    if options is None:
+        options = AutoCodeOptions()
+    core = AutoCoderCore(options)
+    return core.query_sync(f"/new {prompt}", show_terminal)
+
+
+def modify_code(
+    prompt: str,
+    pre_commit: bool = False,
+    extra_args: Optional[Dict[str, Any]] = None,
+    options: Optional[AutoCodeOptions] = None,
+    show_terminal: bool = True
+) -> CodeModificationResult:
+    """
+    代码修改接口
+    
+    Args:
+        prompt: 修改提示
+        pre_commit: 是否预提交
+        extra_args: 额外参数
+        options: 配置选项
+        show_terminal: 是否在终端显示友好的渲染输出
+        
+    Returns:
+        CodeModificationResult: 修改结果
+        
+    Example:
+        >>> from autocoder.sdk import modify_code, AutoCodeOptions
+        >>> 
+        >>> options = AutoCodeOptions(cwd="/path/to/project")
+        >>> result = modify_code(
+        ...     "Add error handling to the main function",
+        ...     pre_commit=False,
+        ...     options=options
+        ... )
+        >>> 
+        >>> if result.success:
+        ...     print(f"Modified files: {result.modified_files}")
+        ... else:
+        ...     print(f"Error: {result.error_details}")
+    """
+    core = AutoCoderCore(options or AutoCodeOptions())
+    return core.modify_code(prompt, pre_commit, extra_args, show_terminal)
+
+
+async def modify_code_stream(
+    prompt: str,
+    pre_commit: bool = False,
+    extra_args: Optional[Dict[str, Any]] = None,
+    options: Optional[AutoCodeOptions] = None,
+    show_terminal: bool = True
+) -> AsyncIterator[StreamEvent]:
+    """
+    异步流式代码修改接口
+    
+    Args:
+        prompt: 修改提示
+        pre_commit: 是否预提交
+        extra_args: 额外参数
+        options: 配置选项
+        show_terminal: 是否在终端显示友好的渲染输出
+        
+    Yields:
+        StreamEvent: 修改事件流
+        
+    Example:
+        >>> import asyncio
+        >>> from autocoder.sdk import modify_code_stream, AutoCodeOptions
+        >>> 
+        >>> async def main():
+        ...     options = AutoCodeOptions(cwd="/path/to/project")
+        ...     async for event in modify_code_stream(
+        ...         "Refactor the user authentication module",
+        ...         options=options
+        ...     ):
+        ...         print(f"[{event.event_type}] {event.data}")
+        >>> 
+        >>> asyncio.run(main())
+    """
+    core = AutoCoderCore(options or AutoCodeOptions())
+    async for event in core.modify_code_stream(prompt, pre_commit, extra_args, show_terminal):
+        yield event

autocoder/sdk/cli/__init__.py

@@ -0,0 +1,15 @@
+"""
+Auto-Coder CLI 模块
+
+提供命令行接口，允许用户通过终端使用 Auto-Coder 的核心功能。
+"""
+
+from .main import AutoCoderCLI
+from .options import CLIOptions, CLIResult
+
+# 导出main函数作为入口点
+def main():
+    """CLI主入口点函数"""
+    return AutoCoderCLI.main()
+
+__all__ = ["AutoCoderCLI", "CLIOptions", "CLIResult", "main"]

autocoder/sdk/cli/__main__.py

@@ -0,0 +1,26 @@
+#!/usr/bin/env python3
+"""
+CLI 模块主入口点
+"""
+
+import sys
+import argparse
+from pathlib import Path
+
+def main():
+    """主入口点，路由到不同的 CLI 功能"""
+    
+    # 检查是否是自动补全相关的命令
+    if len(sys.argv) > 1 and sys.argv[1] in ["install", "uninstall", "test"]:
+        # 路由到自动补全安装工具
+        from .install_completion import main as install_main
+        install_main()
+        return        
+    
+    # 默认显示自动补全工具的帮助
+    from .install_completion import main as install_main
+    install_main()
+
+if __name__ == "__main__":
+    main()
+

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,175 @@
+"""
+命令处理器模块
+
+提供统一的命令处理器，支持单次运行和会话复用功能。
+"""
+
+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,
+            pr=self.options.pr
+        )
+        
+    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)
+
+