tsugite-cli 0.3.3__py3-none-any.whl

tsugite/models.py

@@ -0,0 +1,257 @@
+"""Model adapters for Tsugite agents."""
+
+import os
+import re
+from typing import Optional
+
+
+def resolve_model_alias(model_string: str) -> str:
+    """Resolve a model alias to its full model string.
+
+    Args:
+        model_string: Either an alias name or full model string
+
+    Returns:
+        Full model string (resolved alias or original string)
+
+    Examples:
+        >>> resolve_model_alias("cheap")  # if alias exists
+        "openai:gpt-4o-mini"
+        >>> resolve_model_alias("ollama:qwen2.5-coder:7b")
+        "ollama:qwen2.5-coder:7b"
+    """
+    from tsugite.config import get_model_alias
+
+    if ":" in model_string:
+        return model_string
+
+    alias_value = get_model_alias(model_string)
+    if alias_value:
+        return alias_value
+
+    return model_string
+
+
+def parse_model_string(model_string: str) -> tuple[str, str, Optional[str]]:
+    """Parse Tsugite model string format.
+
+    Args:
+        model_string: Format like "ollama:qwen2.5-coder:14b" or "openai:gpt-4"
+
+    Returns:
+        Tuple of (provider, model_name, variant)
+    """
+    parts = model_string.split(":")
+    if len(parts) < 2:
+        raise ValueError(f"Invalid model string format: {model_string}")
+
+    provider = parts[0]
+    model_name = parts[1]
+    variant = parts[2] if len(parts) > 2 else None
+
+    return provider, model_name, variant
+
+
+def is_reasoning_model_without_stop_support(model_string: str) -> bool:
+    """Check if model is a reasoning model that doesn't support stop sequences.
+
+    OpenAI's o1/o3 reasoning models don't support the stop parameter.
+
+    Args:
+        model_string: Full model string like "openai:o1-mini"
+
+    Returns:
+        True if this is a reasoning model that doesn't support stop sequences
+    """
+    try:
+        provider, model_name, variant = parse_model_string(model_string)
+    except ValueError:
+        return False
+
+    # Only OpenAI reasoning models have this limitation
+    if provider != "openai":
+        return False
+
+    # Check if it's an o1 or o3 model (with optional version suffix)
+    # Matches: o1, o1-mini, o1-preview, o1-2024-12-17, o3, o3-mini, o3-2025-01-31, etc.
+    pattern = r"^(o1|o3)(-mini|-preview)?(-\d{4}-\d{2}-\d{2})?$"
+    return bool(re.match(pattern, model_name))
+
+
+def get_model_params(model_string: str, **kwargs) -> dict:
+    """Get parameters for direct litellm.acompletion() calls.
+
+    Returns a dict with model ID and parameters for direct LiteLLM usage.
+
+    Args:
+        model_string: Model specification like "openai:gpt-4o-mini" or an alias
+        **kwargs: Additional model parameters (reasoning_effort, response_format, temperature, etc.)
+
+    Returns:
+        Dict with "model" key and all parameters ready for litellm.acompletion()
+
+    Examples:
+        >>> params = get_model_params("openai:gpt-4o-mini", temperature=0.7)
+        >>> params["model"]
+        'openai/gpt-4o-mini'
+        >>> params["temperature"]
+        0.7
+
+        >>> # Reasoning models - unsupported params filtered out
+        >>> params = get_model_params("openai:o1", temperature=0.7)
+        >>> "temperature" not in params  # Filtered for o1
+        True
+    """
+    # Resolve aliases and parse model string
+    resolved_model = resolve_model_alias(model_string)
+    provider, model_name, variant = parse_model_string(resolved_model)
+
+    # Build parameters dict
+    params = dict(kwargs)
+
+    # Filter parameters for reasoning models
+    if is_reasoning_model_without_stop_support(resolved_model):
+        params = filter_reasoning_model_params(model_name, params)
+
+    # Build provider-specific parameters
+    if provider == "ollama":
+        return build_ollama_params(model_name, variant, params)
+    elif provider == "openai":
+        return build_openai_params(model_name, params)
+    elif provider == "anthropic":
+        return build_anthropic_params(model_name, params)
+    elif provider == "google":
+        return build_google_params(model_name, params)
+    elif provider == "github_copilot":
+        return build_github_copilot_params(model_name, params)
+    else:
+        return build_fallback_params(provider, model_name, params)
+
+
+def filter_reasoning_model_params(model_name: str, params: dict) -> dict:
+    """Filter out unsupported parameters for reasoning models.
+
+    OpenAI's o1/o3 reasoning models don't support certain parameters.
+
+    Args:
+        model_name: The model name (e.g., "o1", "o1-mini")
+        params: Dictionary of parameters
+
+    Returns:
+        Filtered parameters dict (modifies in-place and returns)
+    """
+    unsupported_params = ["stop", "temperature", "top_p", "presence_penalty", "frequency_penalty"]
+
+    # o1-mini specifically doesn't support reasoning_effort
+    if "o1-mini" in model_name:
+        unsupported_params.append("reasoning_effort")
+
+    # Remove unsupported parameters
+    for param in unsupported_params:
+        params.pop(param, None)
+
+    return params
+
+
+def build_ollama_params(model_name: str, variant: str | None, params: dict) -> dict:
+    """Build parameters for Ollama provider.
+
+    Args:
+        model_name: The model name
+        variant: Optional model variant
+        params: Base parameters dict
+
+    Returns:
+        Updated parameters dict
+    """
+    full_model_name = f"{model_name}:{variant}" if variant else model_name
+    params["model"] = full_model_name
+    params.setdefault("api_base", os.getenv("OLLAMA_BASE_URL", "http://localhost:11434/v1"))
+    params.setdefault("api_key", "ollama")
+    return params
+
+
+def build_openai_params(model_name: str, params: dict) -> dict:
+    """Build parameters for OpenAI provider.
+
+    Args:
+        model_name: The model name
+        params: Base parameters dict
+
+    Returns:
+        Updated parameters dict
+    """
+    params["model"] = f"openai/{model_name}"
+    if "api_key" not in params:
+        params["api_key"] = os.getenv("OPENAI_API_KEY")
+    return params
+
+
+def build_anthropic_params(model_name: str, params: dict) -> dict:
+    """Build parameters for Anthropic provider.
+
+    Args:
+        model_name: The model name
+        params: Base parameters dict
+
+    Returns:
+        Updated parameters dict
+    """
+    params["model"] = f"anthropic/{model_name}"
+    if "api_key" not in params:
+        params["api_key"] = os.getenv("ANTHROPIC_API_KEY")
+    return params
+
+
+def build_google_params(model_name: str, params: dict) -> dict:
+    """Build parameters for Google provider.
+
+    Args:
+        model_name: The model name
+        params: Base parameters dict
+
+    Returns:
+        Updated parameters dict
+    """
+    params["model"] = f"gemini/{model_name}"
+    if "api_key" not in params:
+        params["api_key"] = os.getenv("GOOGLE_API_KEY")
+    return params
+
+
+def build_github_copilot_params(model_name: str, params: dict) -> dict:
+    """Build parameters for GitHub Copilot provider.
+
+    Args:
+        model_name: The model name
+        params: Base parameters dict
+
+    Returns:
+        Updated parameters dict
+    """
+    params["model"] = f"github_copilot/{model_name}"
+
+    # GitHub Copilot requires specific headers
+    extra_headers = params.get("extra_headers", {})
+    if "editor-version" not in extra_headers:
+        extra_headers["editor-version"] = "vscode/1.95.0"
+    if "Copilot-Integration-Id" not in extra_headers:
+        extra_headers["Copilot-Integration-Id"] = "vscode-chat"
+    params["extra_headers"] = extra_headers
+
+    return params
+
+
+def build_fallback_params(provider: str, model_name: str, params: dict) -> dict:
+    """Build parameters for fallback/unknown providers.
+
+    Args:
+        provider: The provider name
+        model_name: The model name
+        params: Base parameters dict
+
+    Returns:
+        Updated parameters dict
+    """
+    params["model"] = f"{provider}/{model_name}"
+    return params

tsugite/renderer.py

@@ -0,0 +1,151 @@
+"""Jinja2 template rendering for agent content."""
+
+import os
+import re
+from datetime import datetime
+from typing import Any, Dict
+
+from jinja2 import DictLoader, Environment, StrictUndefined
+
+
+def now() -> str:
+    return datetime.now().isoformat()
+
+
+def today() -> str:
+    return datetime.now().strftime("%Y-%m-%d")
+
+
+def slugify(text: str) -> str:
+    import re
+
+    text = text.lower()
+    # Replace special characters with dashes, then keep only ASCII letters, numbers, and dashes
+    text = re.sub(r"[^\w\s-]", "-", text, flags=re.ASCII)
+    text = re.sub(r"[-\s]+", "-", text)
+    return text.strip("-")
+
+
+def file_exists(path: str) -> bool:
+    from pathlib import Path
+
+    return Path(path).exists()
+
+
+def is_file(path: str) -> bool:
+    from pathlib import Path
+
+    p = Path(path)
+    return p.exists() and p.is_file()
+
+
+def is_dir(path: str) -> bool:
+    from pathlib import Path
+
+    p = Path(path)
+    return p.exists() and p.is_dir()
+
+
+def read_text(path: str, default: str = "") -> str:
+    from pathlib import Path
+
+    try:
+        return Path(path).read_text(encoding="utf-8")
+    except Exception:
+        return default
+
+
+def strip_ignored_sections(content: str) -> str:
+    """Remove <!-- tsu:ignore --> blocks from content.
+
+    Supports both block and inline forms:
+    - Block: <!-- tsu:ignore -->\\ncontent\\n<!-- /tsu:ignore -->
+    - Inline: <!-- tsu:ignore -->content<!-- /tsu:ignore -->
+
+    Args:
+        content: Raw markdown content
+
+    Returns:
+        Content with ignored sections removed
+
+    Example:
+        >>> content = '''
+        ... Normal content
+        ... <!-- tsu:ignore -->
+        ... This is ignored
+        ... <!-- /tsu:ignore -->
+        ... More content
+        ... '''
+        >>> result = strip_ignored_sections(content)
+        >>> 'This is ignored' not in result
+        True
+    """
+    # Pattern matches opening tag, content (non-greedy), closing tag
+    # Handles both <!-- tsu:ignore --> and <!--tsu:ignore--> (with/without spaces)
+    # Uses non-greedy match (.*?) to handle multiple blocks correctly
+    # DOTALL flag allows matching across newlines
+    pattern = r"<!--\s*tsu:ignore\s*-->.*?<!--\s*/tsu:ignore\s*-->"
+
+    # Remove all ignore blocks
+    result = re.sub(pattern, "", content, flags=re.DOTALL)
+
+    return result
+
+
+class AgentRenderer:
+    """Jinja2 template renderer for agent content."""
+
+    def __init__(self):
+        self.env = Environment(
+            loader=DictLoader({}),
+            undefined=StrictUndefined,
+            trim_blocks=True,
+            lstrip_blocks=True,
+        )
+
+        # Add helper functions
+        self.env.globals.update(
+            {
+                "now": now,
+                "today": today,
+                "slugify": slugify,
+                "file_exists": file_exists,
+                "is_file": is_file,
+                "is_dir": is_dir,
+                "read_text": read_text,
+                "env": dict(os.environ),
+            }
+        )
+
+        # Add filters
+        self.env.filters["slugify"] = slugify
+
+    def render(self, content: str, context: Dict[str, Any] = None) -> str:
+        """Render agent content with Jinja2.
+
+        Preprocessing steps:
+        1. Strip <!-- tsu:ignore --> blocks
+        2. Render Jinja2 template with context
+
+        Args:
+            content: Raw markdown content
+            context: Template variables
+
+        Returns:
+            Rendered content
+
+        Raises:
+            ValueError: If template rendering fails
+        """
+        if context is None:
+            context = {}
+
+        try:
+            # Step 1: Strip ignored sections BEFORE rendering
+            preprocessed = strip_ignored_sections(content)
+
+            # Step 2: Render Jinja2 template
+            template = self.env.from_string(preprocessed)
+            return template.render(**context)
+        except Exception as e:
+            raise ValueError(f"Template rendering failed: {e}") from e

tsugite/shell_tool_config.py

@@ -0,0 +1,265 @@
+"""Configuration loader for custom shell tools."""
+
+from pathlib import Path
+from typing import Dict, List, Optional
+
+import yaml
+
+from .tools.shell_tools import ShellToolDefinition, ShellToolParameter
+from .xdg import get_xdg_config_path
+
+
+def get_custom_tools_config_path() -> Path:
+    """Get the path to custom_tools.yaml config file."""
+    return get_xdg_config_path("custom_tools.yaml")
+
+
+def load_custom_tools_config(path: Optional[Path] = None) -> List[ShellToolDefinition]:
+    """Load custom tool definitions from YAML config.
+
+    Args:
+        path: Path to custom_tools.yaml. If None, uses default XDG path.
+
+    Returns:
+        List of ShellToolDefinition objects
+
+    Example YAML:
+        tools:
+          - name: file_search
+            description: Search files with ripgrep
+            command: "rg {pattern} {path}"
+            timeout: 30
+            parameters:
+              pattern:
+                type: str
+                description: Search pattern
+                required: true
+              path:
+                type: str
+                description: Directory to search
+                default: "."
+    """
+    if path is None:
+        path = get_custom_tools_config_path()
+
+    if not path.exists():
+        return []
+
+    try:
+        with open(path, "r", encoding="utf-8") as f:
+            config = yaml.safe_load(f)
+
+        if not config or "tools" not in config:
+            return []
+
+        definitions = []
+        for tool_def in config["tools"]:
+            # Parse parameters
+            parameters = {}
+            for param_name, param_config in tool_def.get("parameters", {}).items():
+                # Handle multiple formats
+                if isinstance(param_config, dict):
+                    # Full dict format
+                    param_type = param_config.get("type", "str")
+                    description = param_config.get("description", "")
+                    required = param_config.get("required", False)
+                    default = param_config.get("default")
+                    flag = param_config.get("flag")
+                elif isinstance(param_config, str):
+                    # Simple string format - assume it's the type
+                    param_type = param_config if param_config else "str"
+                    description = ""
+                    required = False
+                    default = None
+                    flag = None
+                elif param_config is None:
+                    # Just parameter name, no config
+                    param_type = "str"
+                    description = ""
+                    required = False
+                    default = None
+                    flag = None
+                else:
+                    # Value provided - infer type and use as default
+                    if isinstance(param_config, bool):
+                        param_type = "bool"
+                        default = param_config
+                    elif isinstance(param_config, int):
+                        param_type = "int"
+                        default = param_config
+                    elif isinstance(param_config, float):
+                        param_type = "float"
+                        default = param_config
+                    else:
+                        param_type = "str"
+                        default = str(param_config)
+                    description = ""
+                    required = False
+                    flag = None
+
+                parameters[param_name] = ShellToolParameter(
+                    name=param_name,
+                    type=param_type,
+                    description=description,
+                    required=required,
+                    default=default,
+                    flag=flag,
+                )
+
+            # Create definition
+            definition = ShellToolDefinition(
+                name=tool_def["name"],
+                description=tool_def.get("description", ""),
+                command=tool_def["command"],
+                parameters=parameters,
+                timeout=tool_def.get("timeout", 30),
+                safe_mode=tool_def.get("safe_mode", True),
+                shell=tool_def.get("shell", True),
+            )
+
+            definitions.append(definition)
+
+        return definitions
+
+    except yaml.YAMLError as e:
+        raise ValueError(f"Failed to parse custom tools config: {e}") from e
+    except Exception as e:
+        raise RuntimeError(f"Failed to load custom tools config: {e}") from e
+
+
+def save_custom_tools_config(definitions: List[ShellToolDefinition], path: Optional[Path] = None) -> None:
+    """Save custom tool definitions to YAML config.
+
+    Args:
+        definitions: List of tool definitions to save
+        path: Path to custom_tools.yaml. If None, uses default XDG path.
+    """
+    if path is None:
+        path = get_custom_tools_config_path()
+
+    # Ensure parent directory exists
+    path.parent.mkdir(parents=True, exist_ok=True)
+
+    # Convert definitions to YAML-friendly format
+    tools_config = []
+    for definition in definitions:
+        tool_dict = {
+            "name": definition.name,
+            "description": definition.description,
+            "command": definition.command,
+            "timeout": definition.timeout,
+            "safe_mode": definition.safe_mode,
+            "shell": definition.shell,
+            "parameters": {},
+        }
+
+        # Convert parameters
+        for param_name, param_def in definition.parameters.items():
+            tool_dict["parameters"][param_name] = {
+                "type": param_def.type,
+                "description": param_def.description,
+                "required": param_def.required,
+            }
+
+            if param_def.default is not None:
+                tool_dict["parameters"][param_name]["default"] = param_def.default
+
+            if param_def.flag:
+                tool_dict["parameters"][param_name]["flag"] = param_def.flag
+
+        tools_config.append(tool_dict)
+
+    config = {"tools": tools_config}
+
+    with open(path, "w", encoding="utf-8") as f:
+        yaml.safe_dump(config, f, default_flow_style=False, sort_keys=False)
+
+
+def parse_tool_definition_from_dict(tool_dict: Dict) -> ShellToolDefinition:
+    """Parse a tool definition from a dictionary (e.g., from agent frontmatter).
+
+    Args:
+        tool_dict: Dictionary with tool configuration
+
+    Returns:
+        ShellToolDefinition object
+
+    Example:
+        {
+            "name": "file_search",
+            "command": "rg {pattern} {path}",
+            "parameters": {
+                "pattern": {"type": "str", "required": true},
+                "path": ".",  # Infer type from default value
+                "recursive": true  # Infer bool from value
+            }
+        }
+    """
+    parameters = {}
+    for param_name, param_config in tool_dict.get("parameters", {}).items():
+        if isinstance(param_config, dict):
+            # Full dict format
+            param_type = param_config.get("type", "str")
+            description = param_config.get("description", "")
+            required = param_config.get("required", False)
+            default = param_config.get("default")
+            flag = param_config.get("flag")
+        elif isinstance(param_config, str):
+            # String - assume it's either type name or default value
+            # If it looks like a type name (str, int, bool, float), use it as type
+            if param_config in ("str", "int", "bool", "float"):
+                param_type = param_config
+                description = ""
+                required = False
+                default = None
+                flag = None
+            else:
+                # Otherwise it's a default value
+                param_type = "str"
+                description = ""
+                required = False
+                default = param_config
+                flag = None
+        elif param_config is None:
+            # Just parameter name
+            param_type = "str"
+            description = ""
+            required = False
+            default = None
+            flag = None
+        else:
+            # Value provided - infer type and use as default
+            if isinstance(param_config, bool):
+                param_type = "bool"
+                default = param_config
+            elif isinstance(param_config, int):
+                param_type = "int"
+                default = param_config
+            elif isinstance(param_config, float):
+                param_type = "float"
+                default = param_config
+            else:
+                param_type = "str"
+                default = str(param_config)
+            description = ""
+            required = False
+            flag = None
+
+        parameters[param_name] = ShellToolParameter(
+            name=param_name,
+            type=param_type,
+            description=description,
+            required=required,
+            default=default,
+            flag=flag,
+        )
+
+    return ShellToolDefinition(
+        name=tool_dict["name"],
+        description=tool_dict.get("description", ""),
+        command=tool_dict["command"],
+        parameters=parameters,
+        timeout=tool_dict.get("timeout", 30),
+        safe_mode=tool_dict.get("safe_mode", True),
+        shell=tool_dict.get("shell", True),
+    )

tsugite/templates/assistant.md

@@ -0,0 +1,14 @@
+---
+name: assistant
+description: General-purpose assistant for questions and tasks
+max_steps: 5
+tools: []
+---
+
+# Assistant
+
+You are a helpful assistant. Answer questions clearly and directly, provide explanations when needed, and help with general tasks. Focus on being accurate, concise, and useful.
+
+When you have completed the task, use the final_answer() function to provide your response.
+
+**Task**: {{ user_prompt }}