sourcebot 0.1.0__py3-none-any.whl

sourcebot/tools/rule_detail.py

@@ -0,0 +1,70 @@
+# sourcebot/tools/rule_detail.py
+from sourcebot.tools.base import Tool
+from typing import Any, Optional
+from pathlib import Path
+
+
+class RuleDetailTool(Tool):
+    """Tool for retrieving detailed information about a specific rule."""
+    
+    def __init__(self, rules_loader):
+        """
+        Initialize the RuleDetailTool.
+        
+        Args:
+            rules_loader: Loader instance for accessing rules
+        """
+        self.rules_loader = rules_loader
+
+    @property
+    def name(self) -> str:
+        return "rule_detail"
+
+    @property
+    def description(self) -> str:
+        return (
+            "Get detailed information about a specific rule. "
+            "Provide the rule name to retrieve its full content and requirements."
+        )
+
+    @property
+    def parameters(self) -> dict[str, Any]:
+        return {
+            "type": "object",
+            "properties": {
+                "name": {
+                    "type": "string", 
+                    "description": "The name of the rule to get details for",
+                },
+            },
+            "required": ["name"],
+        }
+
+    async def execute(self, name: str, **kwargs: Any) -> str:
+        """
+        Execute the tool and return detailed information about a specific rule.
+        
+        Args:
+            name: The name of the rule to retrieve
+            
+        Returns:
+            A string containing the rule details, or an error message if not found
+        """
+        try:
+            # Validate input
+            if not name or not isinstance(name, str):
+                return "Error: Rule name must be a non-empty string"
+            
+            # Read rule content
+            rule_content = self.rules_loader.read_rule(name)
+            
+            if not rule_content:
+                return f"No content found for rule: {name}"
+            
+            # Format the output
+            return f"=== Rule: {name} ===\n\n{rule_content}\n\n=== End of Rule ==="
+            
+        except FileNotFoundError:
+            return f"Error: Rule '{name}' not found. Use the rules_list tool to see available rules."
+        except Exception as e:
+            return f"Error reading rule details for '{name}': {str(e)}"

sourcebot/tools/rule_list.py

@@ -0,0 +1,57 @@
+# sourcebot/tools/rule_list.py
+from sourcebot.tools.base import Tool
+from typing import Any, Optional
+
+
+class RuleListTool(Tool):
+    """Tool for listing available rules that need to be followed."""
+    
+    def __init__(self, rules_loader):
+        """
+        Initialize the RuleListTool.
+        
+        Args:
+            rules_loader: Loader instance for accessing rules
+        """
+        self.rules_loader = rules_loader
+
+    @property
+    def name(self) -> str:
+        return "rule_list"
+
+    @property
+    def description(self) -> str:
+        return (
+            "Returns the list of available rules. "
+            "Call this tool to see all rules that must be followed."
+        )
+
+    @property
+    def parameters(self) -> dict[str, Any]:
+        return {
+            "type": "object",
+            "properties": {},
+            "required": []
+        }
+
+    async def execute(self, **kwargs: Any) -> str:
+        """
+        Execute the tool and return the list of available rules.
+        
+        Returns:
+            String containing the list of rules
+        """
+        try:
+            rule_list = self.rules_loader.list_rules_dirs()
+            
+            if not rule_list:
+                return "No rules found."
+            
+            lines = ["Available rules:"]
+            for i, rule in enumerate(rule_list, 1):
+                lines.append(f"{i}. {rule}")
+            
+            return "\n".join(lines)
+            
+        except Exception as e:
+            return f"Error getting rules list: {str(e)}"

sourcebot/tools/shell.py

@@ -0,0 +1,93 @@
+# sourcebot/tools/shell.py
+"""Shell execution tool (executes commands in /workspace)"""
+
+import os
+import re
+from pathlib import Path
+from typing import Any, Optional
+
+from sourcebot.tools.base import Tool
+from sourcebot.docker_sandbox import DockerSandbox
+
+
+class ShellTool(Tool):
+    """Execute shell commands in /workspace"""
+
+    _MAX_OUTPUT = 10_000
+
+    def __init__(
+        self,
+        sandbox: DockerSandbox,
+        timeout: int = 60,
+        working_dir: str | None = None,
+        deny_patterns: list[str] | None = None,
+        allow_patterns: list[str] | None = None,
+    ):
+        self.sandbox = sandbox
+        self.timeout = timeout
+        self.working_dir = working_dir
+        self.deny_patterns = deny_patterns or []
+        self.allow_patterns = allow_patterns or []
+
+    @property
+    def name(self) -> str:
+        return "shell"
+
+    @property
+    def description(self) -> str:
+        return "Execute shell commands (running in /workspace)"
+
+    @property
+    def parameters(self) -> dict[str, Any]:
+        return {
+            "type": "object",
+            "properties": {
+                "command": {
+                    "type": "string",
+                    "description": "Shell command to be executed",
+                },
+                "timeout": {
+                    "type": "integer",
+                    "description": "Command timeout (seconds)",
+                    "minimum": 1,
+                    "maximum": 60,
+                },
+            },
+            "required": ["command"],
+        }
+
+    async def execute(
+        self,
+        command: str,
+        timeout: Optional[int] = None,
+        **kwargs: Any,
+    ) -> str:
+        """Execute command (running in /workspace)"""
+        
+
+        effective_timeout = timeout or self.timeout
+
+        try:
+            # Directly call Docker Sandbox
+            result = await self.sandbox.execute(
+                command,
+                timeout=effective_timeout,
+            )
+
+            if not result:
+                result = "(no output)"
+
+            # Truncate output length
+            if len(result) > self._MAX_OUTPUT:
+                half = self._MAX_OUTPUT // 2
+                result = (
+                    result[:half]
+                    + f"\n\n... ({len(result) - self._MAX_OUTPUT:,} chars truncated) ...\n\n"
+                    + result[-half:]
+                )
+
+            return result
+
+        except Exception as e:
+            return f"Command execution failed: {str(e)}"
+

sourcebot/tools/skill_detail.py

@@ -0,0 +1,61 @@
+# sourcebot/tools/skill_detail.py
+from sourcebot.tools.base import Tool
+from typing import Any, Optional
+from pathlib import Path
+class SkillDetailTool(Tool):
+    """Return to skill details"""
+    
+    def __init__(
+        self,
+        skill_storage,
+        host_workspace,
+    ):
+        self.skill_storage = skill_storage
+        self.host_workspace = host_workspace
+    @property
+    def name(self) -> str:
+        return "skill_detail"
+
+    @property
+    def description(self) -> str:
+        return (
+            "Get the details corresponding to the skill name"
+        )
+
+    @property
+    def parameters(self) -> dict[str, Any]:
+        return {
+            "type": "object",
+            "properties": {
+                "name": {
+                    "type": "string", 
+                    "description": "The name of the skill to get details for",
+                },
+            },
+            "required": ["name"],
+        }
+
+
+    async def execute(
+        self, 
+        name: str,  # Default to skills directory
+        **kwargs: Any,
+    ) -> str:
+        """
+        Execute the tool and return the skill details.
+
+        Args:
+            name: Skill name
+        Returns:
+            A string containing the skill details
+        """
+        try:
+            
+            self.skill_storage.inject_skill(name, self.host_workspace)
+            skill_content = self.skill_storage.read_skill(name)
+            guide_message = f"\n\nSkill data has been injected into /workspace/skills/{name} directory for your reference and use."
+    
+            return skill_content + guide_message
+        except Exception as e:
+            return f"Error reading skill details: {str(e)}"
+        

sourcebot/tools/skill_list.py

@@ -0,0 +1,68 @@
+# sourcebot/tools/skill_list.py
+from sourcebot.tools.base import Tool
+from typing import Any, Optional
+
+class SkillListTool(Tool):
+    """Return to the list of available skills"""
+    
+    def __init__(
+        self,
+        skill_storage,
+    ):
+        self.skill_storage = skill_storage
+    @property
+    def name(self) -> str:
+        return "skill_list"
+
+    @property
+    def description(self) -> str:
+        return (
+            "Return to the skill list.Directly calling this tool will return to the skill catalog list."
+        )
+
+    @property
+    def parameters(self) -> dict[str, Any]:
+        return {
+            "type": "object",
+            "properties": {
+                "path": {
+                    "type": "string", 
+                    "description": "The directory path to list",
+                    "default": "/skills"  # Set default path to skills directory
+                },
+                "recursive": {
+                    "type": "boolean",
+                    "description": "Recursively list all files (default false)",
+                },
+                "max_entries": {
+                    "type": "integer",
+                    "description": "Maximum entries to return (default 200)",
+                    "minimum": 1,
+                },
+            },
+            # Make path optional since we have a default
+            "required": [],
+        }
+
+    async def execute(
+        self, 
+        path: str = "/skills",  # Default to skills directory
+        recursive: bool = False,
+        max_entries: int | None = None, 
+        **kwargs: Any,
+    ) -> str:
+        """
+        Execute the tool and return directory listing.
+        
+        Args:
+            path: Directory path to list (defaults to /skills)
+            recursive: Whether to list recursively
+            max_entries: Maximum number of entries to return
+            
+        Returns:
+            String containing directory listing
+        """
+        try:
+            return self.skill_storage.list_skill_name(source = "all")
+        except Exception as e:
+            return f"Error geting skill list: {str(e)}"

sourcebot/utils/__init__.py

@@ -0,0 +1,2 @@
+from sourcebot.utils.output import extract_json, strip_think, parse_tool_args, ensure_string
+__all__ = ["extract_json", "strip_think", "parse_tool_args", "ensure_string"]

sourcebot/utils/output.py

@@ -0,0 +1,79 @@
+# sourcebot/utils/output.py
+import re
+import json
+
+def extract_json(text: str) -> dict:
+
+    match = re.search(r'```(?:json)?\s*(.*?)```', text, flags=re.DOTALL)
+    if match:
+        text = match.group(1)
+
+    text = text.strip()
+    return json.loads(text)
+
+def strip_think(text: str | None) -> str | None:
+        """Remove <think>…</think> blocks that some models embed in content."""
+        if not text:
+            return None
+        return re.sub(r"<think>[\s\S]*?</think>", "", text).strip() or None
+
+
+
+def parse_tool_args(args):
+    if isinstance(args, dict):
+        return args
+    if isinstance(args, str):
+        try:
+            return json.loads(args)
+        except Exception:
+            return {"input": args}
+    return {}
+
+def ensure_string(value: any, pretty: bool = True) -> str:
+    """
+    Ensure the return value is a string.
+    Args:
+        value: Input value of any type
+
+        pretty: If True, the JSON output will be formatted (indented); otherwise, it will be in compact format.
+
+    Returns:
+        String representation
+    """
+    if value is None:
+        return ""
+    
+    if isinstance(value, str):
+        return value
+    
+    if isinstance(value, bytes):
+        try:
+            return value.decode('utf-8')
+        except UnicodeDecodeError:
+            return str(value)
+    
+    if isinstance(value, (dict, list, tuple, set)):
+        try:
+            import json
+            from datetime import datetime, date
+            
+            def json_serializer(obj):
+                if isinstance(obj, (datetime, date)):
+                    return obj.isoformat()
+                if isinstance(obj, set):
+                    return list(obj)
+                if hasattr(obj, '__dict__'):
+                    return obj.__dict__
+                raise TypeError(f"Type {type(obj)} not serializable")
+            
+            if pretty:
+                return json.dumps(value, ensure_ascii=False, indent=2, default=json_serializer)
+            else:
+                return json.dumps(value, ensure_ascii=False, default=json_serializer)
+        except Exception as e:
+            return f"<Failed to serialize: {e}>\n{str(value)}"
+    
+    if hasattr(value, '__str__'):
+        return str(value)
+    
+    return repr(value)