auto-coder 0.1.286__py3-none-any.whl → 0.1.288__py3-none-any.whl

autocoder/plugins/dynamic_completion_example.py

@@ -0,0 +1,148 @@
+"""
+Dynamic Completion Example Plugin for Chat Auto Coder.
+"""
+
+from typing import Any, Callable, Dict, List, Optional, Tuple, Type, Union
+from autocoder.plugins import Plugin, PluginManager
+
+
+class DynamicCompletionExamplePlugin(Plugin):
+    """A sample plugin demonstrating dynamic completion functionality."""
+
+    name = "dynamic_completion_example"
+    description = "Demonstrates the dynamic completion feature"
+    version = "0.1.0"
+
+    def __init__(self, manager: PluginManager, config: Optional[Dict[str, Any]] = None, config_path: Optional[str] = None):
+        """Initialize the plugin.
+
+        Args:
+            manager: The plugin manager instance
+            config: Optional configuration dictionary for the plugin
+            config_path: Optional path to the configuration file
+        """
+        super().__init__(manager, config, config_path)
+        self.items = ["item1", "item2", "item3", "custom_item"]
+
+    def initialize(self) -> bool:
+        """Initialize the plugin.
+
+        Returns:
+            True if initialization was successful, False otherwise
+        """
+        # Register for function interception if needed
+        # self.manager.register_function_interception(self.name, "ask")
+
+        # Register as a dynamic completion provider
+        self.manager.register_dynamic_completion_provider(self.name, ["/example"])
+
+        return True
+
+    def get_commands(self) -> Dict[str, Tuple[Callable, str]]:
+        """Get commands provided by this plugin.
+
+        Returns:
+            A dictionary of command name to handler and description
+        """
+        return {
+            "example": (
+                self.example_command,
+                "Example command with dynamic completion",
+            ),
+            "example/add": (self.add_item, "Add a new item to the example list"),
+            "example/list": (self.list_items, "List all available items"),
+        }
+
+    def get_completions(self) -> Dict[str, List[str]]:
+        """Get completions provided by this plugin.
+
+        Returns:
+            A dictionary mapping command prefixes to completion options
+        """
+        # 基本的静态补全选项
+        return {
+            "/example": ["add", "list", "select"],
+        }
+
+    def get_dynamic_completions(
+        self, command: str, current_input: str
+    ) -> List[Tuple[str, str]]:
+        """Get dynamic completions based on the current command context.
+
+        Args:
+            command: The base command (e.g., "/example select")
+            current_input: The full current input including the command
+
+        Returns:
+            A list of tuples containing (completion_text, display_text)
+        """
+        # 如果是 /example select 命令，提供动态项目列表
+        if current_input.startswith("/example select"):
+            # 提取已输入的部分项目名
+            parts = current_input.split(maxsplit=2)
+            item_prefix = ""
+            if len(parts) > 2:
+                item_prefix = parts[2]
+
+            # 返回匹配的项目
+            return [
+                (item, f"{item} (example item)")
+                for item in self.items
+                if item.startswith(item_prefix)
+            ]
+
+        return []
+
+    def example_command(self, args: str) -> None:
+        """Handle the example command.
+
+        Args:
+            args: Command arguments
+        """
+        if not args:
+            print("Usage: /example [add|list|select]")
+            return
+
+        parts = args.split(maxsplit=1)
+        subcommand = parts[0]
+
+        if subcommand == "select" and len(parts) > 1:
+            item = parts[1]
+            if item in self.items:
+                print(f"Selected item: {item}")
+            else:
+                print(
+                    f"Item '{item}' not found. Use /example list to see available items."
+                )
+        else:
+            print(f"Unknown subcommand: {subcommand}. Use add, list, or select.")
+
+    def add_item(self, args: str) -> None:
+        """Add a new item to the list.
+
+        Args:
+            args: The item name to add
+        """
+        if not args:
+            print("Please specify an item name to add.")
+            return
+
+        if args in self.items:
+            print(f"Item '{args}' already exists.")
+        else:
+            self.items.append(args)
+            print(f"Added item: {args}")
+
+    def list_items(self, args: str) -> None:
+        """List all available items.
+
+        Args:
+            args: Ignored
+        """
+        print("Available items:")
+        for item in self.items:
+            print(f"  - {item}")
+
+    def shutdown(self) -> None:
+        """Shutdown the plugin."""
+        pass

autocoder/plugins/git_helper_plugin.py

@@ -0,0 +1,252 @@
+"""
+Git Helper Plugin for Chat Auto Coder.
+Provides convenient Git commands and information display.
+"""
+
+import os
+import subprocess
+from typing import Any, Callable, Dict, List, Optional, Tuple
+
+from autocoder.plugins import Plugin, PluginManager
+
+
+class GitHelperPlugin(Plugin):
+    """Git helper plugin for the Chat Auto Coder."""
+
+    name = "git_helper"
+    description = "Git helper plugin providing Git commands and status"
+    version = "0.1.0"
+
+    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)
+        self.git_available = self._check_git_available()
+        self.default_branch = self.config.get("default_branch", "main")
+
+    def _check_git_available(self) -> bool:
+        """Check if Git is available."""
+        try:
+            subprocess.run(
+                ["git", "--version"],
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE,
+                check=True,
+            )
+            return True
+        except Exception:
+            return False
+
+    def initialize(self) -> bool:
+        """Initialize the plugin.
+
+        Returns:
+            True if initialization was successful
+        """
+        if not self.git_available:
+            print(f"[{self.name}] 警告: Git不可用，某些功能受限")
+            return True
+
+        print(f"[{self.name}] Git助手插件已初始化")
+        return True
+
+    def get_commands(self) -> Dict[str, Tuple[Callable, str]]:
+        """Get commands provided by this plugin.
+
+        Returns:
+            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)"),
+        }
+
+    def get_completions(self) -> Dict[str, List[str]]:
+        """Get completions provided by this plugin.
+
+        Returns:
+            A dictionary mapping command prefixes to completion options
+        """
+        completions = {
+            "/git/status": [],
+            "/git/commit": [],
+            "/git/branch": [],
+            "/git/checkout": [],
+            "/git/diff": [],
+            "/git/log": [],
+            "/git/pull": [],
+            "/git/push": [],
+            "/git/reset": ["hard", "soft", "mixed"],
+        }
+
+        # 添加分支补全
+        if self.git_available:
+            try:
+                branches = self._get_git_branches()
+                completions["/git/checkout"] = branches
+                completions["/git/branch"] = branches + [
+                    "--delete",
+                    "--all",
+                    "--remote",
+                    "new",
+                ]
+            except Exception:
+                pass
+
+        return completions
+
+    def _run_git_command(self, args: List[str]) -> Tuple[int, str, str]:
+        """Run a Git command.
+
+        Args:
+            args: The command arguments
+
+        Returns:
+            A tuple of (return_code, stdout, stderr)
+        """
+        if not self.git_available:
+            return 1, "", "Git不可用"
+
+        try:
+            process = subprocess.run(
+                ["git"] + args,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE,
+                text=True,
+            )
+            return process.returncode, process.stdout, process.stderr
+        except Exception as e:
+            return 1, "", str(e)
+
+    def _get_git_branches(self) -> List[str]:
+        """Get Git branches.
+
+        Returns:
+            A list of branch names
+        """
+        code, stdout, _ = self._run_git_command(
+            ["branch", "--list", "--format=%(refname:short)"]
+        )
+        if code == 0:
+            return [b.strip() for b in stdout.splitlines() if b.strip()]
+        return []
+
+    def git_status(self, args: str) -> None:
+        """Handle the git/status command."""
+        code, stdout, stderr = self._run_git_command(["status"])
+        if code == 0:
+            print(f"\n{stdout}")
+        else:
+            print(f"Error: {stderr}")
+
+    def git_commit(self, args: str) -> None:
+        """Handle the git/commit command."""
+        if not args:
+            print("请提供提交信息，例如: /git/commit 'Fix bug in login'")
+            return
+
+        # 首先执行添加所有更改 (git add .)
+        self._run_git_command(["add", "."])
+
+        # 执行提交
+        code, stdout, stderr = self._run_git_command(["commit", "-m", args])
+        if code == 0:
+            print(f"\n{stdout}")
+        else:
+            print(f"Error: {stderr}")
+
+    def git_branch(self, args: str) -> None:
+        """Handle the git/branch command."""
+        args_list = args.split() if args else []
+        code, stdout, stderr = self._run_git_command(["branch"] + args_list)
+        if code == 0:
+            print(f"\n{stdout}")
+        else:
+            print(f"Error: {stderr}")
+
+    def git_checkout(self, args: str) -> None:
+        """Handle the git/checkout command."""
+        if not args:
+            print("请提供分支名称，例如: /git/checkout main")
+            return
+
+        args_list = args.split()
+        code, stdout, stderr = self._run_git_command(["checkout"] + args_list)
+        if code == 0:
+            print(f"\n{stdout}")
+        else:
+            print(f"Error: {stderr}")
+
+    def git_diff(self, args: str) -> None:
+        """Handle the git/diff command."""
+        args_list = args.split() if args else []
+        code, stdout, stderr = self._run_git_command(["diff"] + args_list)
+        if code == 0:
+            if stdout:
+                print(f"\n{stdout}")
+            else:
+                print("没有差异")
+        else:
+            print(f"Error: {stderr}")
+
+    def git_log(self, args: str) -> None:
+        """Handle the git/log command."""
+        args_list = args.split() if args else ["--oneline", "-n", "10"]
+        code, stdout, stderr = self._run_git_command(["log"] + args_list)
+        if code == 0:
+            print(f"\n{stdout}")
+        else:
+            print(f"Error: {stderr}")
+
+    def git_pull(self, args: str) -> None:
+        """Handle the git/pull command."""
+        args_list = args.split() if args else []
+        code, stdout, stderr = self._run_git_command(["pull"] + args_list)
+        if code == 0:
+            print(f"\n{stdout}")
+        else:
+            print(f"Error: {stderr}")
+
+    def git_push(self, args: str) -> None:
+        """Handle the git/push command."""
+        args_list = args.split() if args else []
+        code, stdout, stderr = self._run_git_command(["push"] + args_list)
+        if code == 0:
+            print(f"\n{stdout}")
+        else:
+            print(f"Error: {stderr}")
+
+    def handle_reset(self, args: str) -> None:
+        """Handle the git/reset command.
+        
+        Args:
+            args: The reset mode (hard/soft/mixed) and optional commit hash
+        """
+        if not args:
+            print("请提供重置模式 (hard/soft/mixed) 和可选的提交哈希")
+            return
+            
+        args_list = args.split()
+        mode = args_list[0]
+        commit = args_list[1] if len(args_list) > 1 else "HEAD"
+        
+        if mode not in ["hard", "soft", "mixed"]:
+            print(f"错误: 无效的重置模式 '{mode}'，必须是 hard/soft/mixed 之一")
+            return
+            
+        code, stdout, stderr = self._run_git_command(["reset", f"--{mode}", commit])
+        if code == 0:
+            print(f"\n{stdout}")
+            print(f"成功将仓库重置为 {mode} 模式到 {commit}")
+        else:
+            print(f"Error: {stderr}")
+
+    def shutdown(self) -> None:
+        """Shutdown the plugin."""
+        print(f"[{self.name}] Git助手插件已关闭")

autocoder/plugins/sample_plugin.py

@@ -0,0 +1,160 @@
+"""
+Sample plugin demonstrating the plugin system functionality.
+"""
+
+from typing import Any, Callable, Dict, List, Optional, Tuple
+
+from prompt_toolkit.key_binding import KeyBindings
+from prompt_toolkit.formatted_text import FormattedText
+
+from autocoder.plugins import Plugin, PluginManager
+
+
+class SamplePlugin(Plugin):
+    """A sample plugin demonstrating the plugin system functionality."""
+
+    name = "sample_plugin"
+    description = "A sample plugin demonstrating the plugin system features"
+    version = "0.1.0"
+
+    def __init__(self, manager: PluginManager, config: Optional[Dict[str, Any]] = None, config_path: Optional[str] = None):
+        """Initialize the sample plugin."""
+        super().__init__(manager, config, config_path)
+        self.counter = 0
+
+    def initialize(self) -> bool:
+        """Initialize the plugin.
+
+        Returns:
+            True if initialization was successful
+        """
+        print(f"[{self.name}] Initializing sample plugin")
+
+        # Register interest in intercepting functions
+        self.manager.register_function_interception(self.name, "ask")
+        self.manager.register_function_interception(self.name, "coding")
+
+        return True
+
+    def get_commands(self) -> Dict[str, Tuple[Callable, str]]:
+        """Get commands provided by this plugin.
+
+        Returns:
+            A dictionary of command name to handler and description
+        """
+        return {
+            "sample": (self.sample_command, "Sample plugin command"),
+            "counter": (self.counter_command, "Show the plugin counter"),
+        }
+
+    def get_keybindings(self) -> List[Tuple[str, Callable, str]]:
+        """Get keybindings provided by this plugin.
+
+        Returns:
+            A list of (key_combination, handler, description) tuples
+        """
+
+        def increment_counter(event):
+            self.counter += 1
+            print(f"[{self.name}] Counter incremented to {self.counter}")
+
+        return [
+            ("c-p", increment_counter, "Increment plugin counter"),
+        ]
+
+    def get_completions(self) -> Dict[str, List[str]]:
+        """Get completions provided by this plugin.
+
+        Returns:
+            A dictionary mapping command prefixes to completion options
+        """
+        return {
+            "/sample": ["option1", "option2", "option3"],
+            "/counter": ["show", "reset", "increment"],
+        }
+
+    def sample_command(self, args: str) -> None:
+        """Handle the sample command.
+
+        Args:
+            args: Command arguments
+        """
+        print(f"[{self.name}] Sample command executed with args: {args}")
+        self.counter += 1
+        print(f"[{self.name}] Counter incremented to {self.counter}")
+
+    def counter_command(self, args: str) -> None:
+        """Handle the counter command.
+
+        Args:
+            args: Command arguments
+        """
+        if args == "reset":
+            self.counter = 0
+            print(f"[{self.name}] Counter reset to {self.counter}")
+        elif args == "increment":
+            self.counter += 1
+            print(f"[{self.name}] Counter incremented to {self.counter}")
+        else:
+            print(f"[{self.name}] Current counter value: {self.counter}")
+
+    def intercept_command(
+        self, command: str, args: str
+    ) -> Tuple[bool, Optional[str], Optional[str]]:
+        """Intercept commands.
+
+        Args:
+            command: The command name (without the /)
+            args: The command arguments
+
+        Returns:
+            A tuple of (should_continue, modified_command, modified_args)
+        """
+        # Log all commands
+        print(f"[{self.name}] Command intercepted: /{command} {args}")
+
+        # Example: modify the 'ask' command to add a prefix
+        if command == "ask" and args:
+            return True, command, f"[From Sample Plugin] {args}"
+
+        return True, command, args
+
+    def intercept_function(
+        self, func_name: str, args: List[Any], kwargs: Dict[str, Any]
+    ) -> Tuple[bool, List[Any], Dict[str, Any]]:
+        """Intercept function calls.
+
+        Args:
+            func_name: The function name
+            args: The positional arguments
+            kwargs: The keyword arguments
+
+        Returns:
+            A tuple of (should_continue, modified_args, modified_kwargs)
+        """
+        print(f"[{self.name}] Function intercepted: {func_name}")
+
+        # Example: modify the 'coding' function to add a prefix to the query
+        if func_name == "coding" and args:
+            args = list(args)  # Convert tuple to list for modification
+            if isinstance(args[0], str):
+                args[0] = f"[Enhanced by Sample Plugin] {args[0]}"
+
+        return True, args, kwargs
+
+    def post_function(self, func_name: str, result: Any) -> Any:
+        """Process function results.
+
+        Args:
+            func_name: The function name
+            result: The function result
+
+        Returns:
+            The possibly modified result
+        """
+        print(f"[{self.name}] Function completed: {func_name}")
+        return result
+
+    def shutdown(self) -> None:
+        """Shutdown the plugin."""
+        print(f"[{self.name}] Shutting down sample plugin (counter: {self.counter})")