open-swarm 0.1.1744937124__py3-none-any.whl → 0.1.1744942852__py3-none-any.whl

swarm/extensions/blueprint/output_utils.py

@@ -1,173 +0,0 @@
-"""
-Output utilities for Swarm blueprints.
-"""
-
-import json
-import logging
-import os
-import sys
-from typing import List, Dict, Any
-
-# Optional import for markdown rendering
-try:
-    from rich.markdown import Markdown
-    from rich.console import Console
-    from rich.panel import Panel
-    from rich.text import Text
-    from rich.rule import Rule
-    RICH_AVAILABLE = True
-except ImportError:
-    RICH_AVAILABLE = False
-
-logger = logging.getLogger(__name__)
-
-def render_markdown(content: str) -> None:
-    """Render markdown content using rich, if available."""
-    # --- DEBUG PRINT ---
-    print(f"\n[DEBUG render_markdown called with rich={RICH_AVAILABLE}]", flush=True)
-    if not RICH_AVAILABLE:
-        print(content, flush=True) # Fallback print with flush
-        return
-    console = Console()
-    md = Markdown(content)
-    console.print(md) # Rich handles flushing
-
-def ansi_box(title: str, content: str, color: str = "94", emoji: str = "🔎", border: str = "─", width: int = 70) -> str:
-    """Return a string or Panel with ANSI box formatting for search/analysis results using Rich if available."""
-    if RICH_AVAILABLE:
-        console = Console()
-        # Rich supports color names or hex, map color code to name
-        color_map = {
-            "94": "bright_blue",
-            "96": "bright_cyan",
-            "92": "bright_green",
-            "93": "bright_yellow",
-            "91": "bright_red",
-            "95": "bright_magenta",
-            "90": "grey82",
-        }
-        style = color_map.get(color, "bright_blue")
-        panel = Panel(
-            content,
-            title=f"{emoji} {title} {emoji}",
-            border_style=style,
-            width=width
-        )
-        # Return the rendered panel as a string for testability
-        with console.capture() as capture:
-            console.print(panel)
-        return capture.get()
-    # Fallback: legacy manual ANSI box
-    top = f"\033[{color}m{emoji} {border * (width - 4)} {emoji}\033[0m"
-    mid_title = f"\033[{color}m│ {title.center(width - 6)} │\033[0m"
-    lines = content.splitlines()
-    boxed = [top, mid_title, top]
-    for line in lines:
-        boxed.append(f"\033[{color}m│\033[0m {line.ljust(width - 6)} \033[{color}m│\033[0m")
-    boxed.append(top)
-    return "\n".join(boxed)
-
-def print_search_box(title: str, content: str, color: str = "94", emoji: str = "🔎"):
-    print(ansi_box(title, content, color=color, emoji=emoji))
-
-def pretty_print_response(messages: List[Dict[str, Any]], use_markdown: bool = False, spinner=None) -> None:
-    """Format and print messages, optionally rendering assistant content as markdown."""
-    # --- DEBUG PRINT ---
-    print(f"\n[DEBUG pretty_print_response called with {len(messages)} messages, use_markdown={use_markdown}]", flush=True)
-
-    if spinner:
-        spinner.stop()
-        sys.stdout.write("\r\033[K") # Clear spinner line
-        sys.stdout.flush()
-
-    if not messages:
-        logger.debug("No messages to print in pretty_print_response.")
-        return
-
-    for i, msg in enumerate(messages):
-         # --- DEBUG PRINT ---
-        print(f"\n[DEBUG Processing message {i}: type={type(msg)}]", flush=True)
-        if not isinstance(msg, dict):
-            print(f"[DEBUG Skipping non-dict message {i}]", flush=True)
-            continue
-
-        role = msg.get("role")
-        sender = msg.get("sender", role if role else "Unknown")
-        msg_content = msg.get("content")
-        tool_calls = msg.get("tool_calls")
-        # --- DEBUG PRINT ---
-        print(f"[DEBUG Message {i}: role={role}, sender={sender}, has_content={bool(msg_content)}, has_tools={bool(tool_calls)}]", flush=True)
-
-
-        if role == "assistant":
-            print(f"\033[94m{sender}\033[0m: ", end="", flush=True)
-            if msg_content:
-                 # --- DEBUG PRINT ---
-                print(f"\n[DEBUG Assistant content found, printing/rendering... Rich={RICH_AVAILABLE}, Markdown={use_markdown}]", flush=True)
-                if use_markdown and RICH_AVAILABLE:
-                    render_markdown(msg_content)
-                else:
-                    # --- DEBUG PRINT ---
-                    print(f"\n[DEBUG Using standard print for content:]", flush=True)
-                    print(msg_content, flush=True) # Added flush
-            elif not tool_calls:
-                print(flush=True) # Flush newline if no content/tools
-
-            if tool_calls and isinstance(tool_calls, list):
-                print("  \033[92mTool Calls:\033[0m", flush=True)
-                for tc in tool_calls:
-                    if not isinstance(tc, dict): continue
-                    func = tc.get("function", {})
-                    tool_name = func.get("name", "Unnamed Tool")
-                    args_str = func.get("arguments", "{}")
-                    try: args_obj = json.loads(args_str); args_pretty = ", ".join(f"{k}={v!r}" for k, v in args_obj.items())
-                    except json.JSONDecodeError: args_pretty = args_str
-                    print(f"    \033[95m{tool_name}\033[0m({args_pretty})", flush=True)
-
-        elif role == "tool":
-            tool_name = msg.get("tool_name", msg.get("name", "tool"))
-            tool_id = msg.get("tool_call_id", "N/A")
-            try: content_obj = json.loads(msg_content); pretty_content = json.dumps(content_obj, indent=2)
-            except (json.JSONDecodeError, TypeError): pretty_content = msg_content
-            print(f"  \033[93m[{tool_name} Result ID: {tool_id}]\033[0m:\n    {pretty_content.replace(chr(10), chr(10) + '    ')}", flush=True)
-        else:
-            # --- DEBUG PRINT ---
-            print(f"[DEBUG Skipping message {i} with role '{role}']", flush=True)
-
-def print_terminal_command_result(cmd: str, result: dict, max_lines: int = 10):
-    """
-    Render a terminal command result in the CLI with a shell prompt emoji, header, and Rich box.
-    - Header: 🐚 Ran terminal command
-    - Top line: colored, [basename(pwd)] > [cmd]
-    - Output: Rich Panel, max 10 lines, tailing if longer, show hint for toggle
-    """
-    if not RICH_AVAILABLE:
-        # Fallback to simple print
-        print(f"🐚 Ran terminal command\n[{os.path.basename(result['cwd'])}] > {cmd}")
-        lines = result['output'].splitlines()
-        if len(lines) > max_lines:
-            lines = lines[-max_lines:]
-            print("[Output truncated. Showing last 10 lines.]")
-        print("\n".join(lines))
-        return
-
-    console = Console()
-    cwd_base = os.path.basename(result['cwd'])
-    header = Text(f"🐚 Ran terminal command", style="bold yellow")
-    subheader = Rule(f"[{cwd_base}] > {cmd}", style="bright_black")
-    lines = result['output'].splitlines()
-    truncated = False
-    if len(lines) > max_lines:
-        lines = lines[-max_lines:]
-        truncated = True
-    output_body = "\n".join(lines)
-    panel = Panel(
-        output_body,
-        title="Output",
-        border_style="cyan",
-        subtitle="[Output truncated. Showing last 10 lines. Press [t] to expand.]" if truncated else "",
-        width=80
-    )
-    console.print(header)
-    console.print(subheader)
-    console.print(panel)

swarm/extensions/blueprint/slash_commands.py

@@ -1,17 +0,0 @@
-# Minimal slash_commands.py to restore compatibility
-
-class SlashCommandRegistry:
-    def __init__(self):
-        self.commands = {}
-    def register(self, command, func=None):
-        if func is None:
-            def decorator(f):
-                self.commands[command] = f
-                return f
-            return decorator
-        self.commands[command] = func
-        return func
-    def get(self, command):
-        return self.commands.get(command)
-
-slash_registry = SlashCommandRegistry()

swarm/extensions/blueprint/spinner.py

@@ -1,100 +0,0 @@
-"""
-Simple terminal spinner for interactive feedback during long operations.
-"""
-
-import os
-import sys
-import threading
-import time
-from typing import Optional
-
-class Spinner:
-    """Simple terminal spinner for interactive feedback."""
-    # Define spinner characters (can be customized)
-    SPINNER_CHARS = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏']
-    # Custom status sequences for special cases
-    STATUS_SEQUENCES = {
-        'generating': ['Generating.', 'Generating..', 'Generating...'],
-        'running': ['Running...']
-    }
-
-    def __init__(self, interactive: bool, custom_sequence: str = None):
-        """
-        Initialize the spinner.
-
-        Args:
-            interactive (bool): Hint whether the environment is interactive.
-                                Spinner is disabled if False or if output is not a TTY.
-            custom_sequence (str): Optional name for a custom status sequence (e.g., 'generating', 'running').
-        """
-        self.interactive = interactive
-        self.is_tty = sys.stdout.isatty()
-        self.enabled = self.interactive and self.is_tty
-        self.running = False
-        self.thread: Optional[threading.Thread] = None
-        self.status = ""
-        self.index = 0
-        self.custom_sequence = custom_sequence
-        self.sequence_idx = 0
-
-    def start(self, status: str = "Processing..."):
-        """Start the spinner with an optional status message."""
-        if not self.enabled or self.running:
-            return # Do nothing if disabled or already running
-        self.status = status
-        self.running = True
-        self.sequence_idx = 0
-        self.thread = threading.Thread(target=self._spin, daemon=True)
-        self.thread.start()
-
-    def stop(self):
-        """Stop the spinner and clear the line."""
-        if not self.enabled or not self.running:
-            return # Do nothing if disabled or not running
-        self.running = False
-        if self.thread is not None:
-            self.thread.join() # Wait for the thread to finish
-        sys.stdout.write("\r\033[K")
-        sys.stdout.flush()
-        self.thread = None
-
-    def _spin(self):
-        """Internal method running in the spinner thread to animate."""
-        start_time = time.time()
-        warned = False
-        while self.running:
-            elapsed = time.time() - start_time
-            if self.custom_sequence and self.custom_sequence in self.STATUS_SEQUENCES:
-                seq = self.STATUS_SEQUENCES[self.custom_sequence]
-                # If taking longer than 10s, show special message
-                if elapsed > 10 and not warned:
-                    msg = f"{seq[-1]} Taking longer than expected"
-                    warned = True
-                else:
-                    msg = seq[self.sequence_idx % len(seq)]
-                sys.stdout.write(f"\r{msg}\033[K")
-                sys.stdout.flush()
-                self.sequence_idx += 1
-            else:
-                char = self.SPINNER_CHARS[self.index % len(self.SPINNER_CHARS)]
-                sys.stdout.write(f"\r{char} {self.status}\033[K")
-                sys.stdout.flush()
-                self.index += 1
-            time.sleep(0.4 if self.custom_sequence else 0.1)
-
-# Example usage (if run directly)
-if __name__ == "__main__":
-    print("Starting spinner test...")
-    s = Spinner(interactive=True) # Assume interactive for testing
-    s.start("Doing something cool")
-    try:
-        time.sleep(5) # Simulate work
-        s.stop()
-        print("Spinner stopped.")
-        s.start("Doing another thing")
-        time.sleep(3)
-    except KeyboardInterrupt:
-        print("\nInterrupted.")
-    finally:
-        s.stop() # Ensure spinner stops on exit/error
-        print("Test finished.")

swarm/extensions/config/config_manager.py

@@ -1,258 +0,0 @@
-# src/swarm/extensions/config/config_manager.py
-
-import json
-import shutil
-import sys
-import logging
-from typing import Any, Dict
-
-from swarm.extensions.config.config_loader import (
-    load_server_config,
-    resolve_placeholders
-)
-from swarm.utils.color_utils import color_text
-from swarm.settings import DEBUG
-from swarm.extensions.cli.utils import (
-    prompt_user,
-    log_and_exit,
-    display_message
-)
-
-# Initialize logger for this module
-logger = logging.getLogger(__name__)
-logger.setLevel(logging.DEBUG if DEBUG else logging.INFO)
-if not logger.handlers:
-    stream_handler = logging.StreamHandler()
-    formatter = logging.Formatter("[%(levelname)s] %(asctime)s - %(name)s - %(message)s")
-    stream_handler.setFormatter(formatter)
-    logger.addHandler(stream_handler)
-
-CONFIG_BACKUP_SUFFIX = ".backup"
-
-def backup_configuration(config_path: str) -> None:
-    """
-    Create a backup of the existing configuration file.
-
-    Args:
-        config_path (str): Path to the configuration file.
-    """
-    backup_path = config_path + CONFIG_BACKUP_SUFFIX
-    try:
-        shutil.copy(config_path, backup_path)
-        logger.info(f"Configuration backup created at '{backup_path}'")
-        display_message(f"Backup of configuration created at '{backup_path}'", "info")
-    except Exception as e:
-        logger.error(f"Failed to create configuration backup: {e}")
-        display_message(f"Failed to create backup: {e}", "error")
-        sys.exit(1)
-
-def load_config(config_path: str) -> Dict[str, Any]:
-    """
-    Load the server configuration from a JSON file and resolve placeholders.
-
-    Args:
-        config_path (str): Path to the configuration file.
-
-    Returns:
-        Dict[str, Any]: The resolved configuration.
-
-    Raises:
-        FileNotFoundError: If the configuration file does not exist.
-        ValueError: If the file contains invalid JSON or unresolved placeholders.
-    """
-    try:
-        with open(config_path, "r") as file:
-            config = json.load(file)
-            logger.debug(f"Raw configuration loaded: {config}")
-    except FileNotFoundError:
-        logger.error(f"Configuration file not found at {config_path}")
-        display_message(f"Configuration file not found at {config_path}", "error")
-        sys.exit(1)
-    except json.JSONDecodeError as e:
-        logger.error(f"Invalid JSON in configuration file {config_path}: {e}")
-        display_message(f"Invalid JSON in configuration file {config_path}: {e}", "error")
-        sys.exit(1)
-
-    # Resolve placeholders recursively
-    try:
-        resolved_config = resolve_placeholders(config)
-        logger.debug(f"Configuration after resolving placeholders: {resolved_config}")
-    except Exception as e:
-        logger.error(f"Failed to resolve placeholders in configuration: {e}")
-        display_message(f"Failed to resolve placeholders in configuration: {e}", "error")
-        sys.exit(1)
-
-    return resolved_config
-
-def save_config(config_path: str, config: Dict[str, Any]) -> None:
-    """
-    Save the updated configuration to the config file.
-
-    Args:
-        config_path (str): Path to the configuration file.
-        config (Dict[str, Any]): Configuration dictionary to save.
-
-    Raises:
-        SystemExit: If saving the configuration fails.
-    """
-    try:
-        with open(config_path, "w") as f:
-            json.dump(config, f, indent=4)
-        logger.info(f"Configuration saved to '{config_path}'")
-        display_message(f"Configuration saved to '{config_path}'", "info")
-    except Exception as e:
-        logger.error(f"Failed to save configuration: {e}")
-        display_message(f"Failed to save configuration: {e}", "error")
-        sys.exit(1)
-
-def add_llm(config_path: str) -> None:
-    """
-    Add a new LLM to the configuration.
-
-    Args:
-        config_path (str): Path to the configuration file.
-    """
-    config = load_config(config_path)
-    display_message("Starting the process to add a new LLM.", "info")
-
-    while True:
-        llm_name = prompt_user("Enter the name of the new LLM (or type 'done' to finish)").strip()
-        display_message(f"User entered LLM name: {llm_name}", "info")
-        if llm_name.lower() == 'done':
-            display_message("Finished adding LLMs.", "info")
-            break
-        if not llm_name:
-            display_message("LLM name cannot be empty.", "error")
-            continue
-
-        if llm_name in config.get("llm", {}):
-            display_message(f"LLM '{llm_name}' already exists.", "warning")
-            continue
-
-        llm = {}
-        llm["provider"] = prompt_user("Enter the provider type (e.g., 'openai', 'ollama')").strip()
-        llm["model"] = prompt_user("Enter the model name (e.g., 'gpt-4')").strip()
-        llm["base_url"] = prompt_user("Enter the base URL for the API").strip()
-        llm_api_key_input = prompt_user("Enter the environment variable for the API key (e.g., 'OPENAI_API_KEY') or leave empty if not required").strip()
-        if llm_api_key_input:
-            llm["api_key"] = f"${{{llm_api_key_input}}}"
-        else:
-            llm["api_key"] = ""
-        try:
-            temperature_input = prompt_user("Enter the temperature (e.g., 0.7)").strip()
-            llm["temperature"] = float(temperature_input)
-        except ValueError:
-            display_message("Invalid temperature value. Using default 0.7.", "warning")
-            llm["temperature"] = 0.7
-
-        config.setdefault("llm", {})[llm_name] = llm
-        logger.info(f"Added LLM '{llm_name}' to configuration.")
-        display_message(f"LLM '{llm_name}' added.", "info")
-
-    backup_configuration(config_path)
-    save_config(config_path, config)
-    display_message("LLM configuration process completed.", "info")
-
-def remove_llm(config_path: str, llm_name: str) -> None:
-    """
-    Remove an existing LLM from the configuration.
-
-    Args:
-        config_path (str): Path to the configuration file.
-        llm_name (str): Name of the LLM to remove.
-    """
-    config = load_config(config_path)
-
-    if llm_name not in config.get("llm", {}):
-        display_message(f"LLM '{llm_name}' does not exist.", "error")
-        return
-
-    confirm = prompt_user(f"Are you sure you want to remove LLM '{llm_name}'? (yes/no)").strip().lower()
-    if confirm not in ['yes', 'y']:
-        display_message("Operation cancelled.", "warning")
-        return
-
-    del config["llm"][llm_name]
-    backup_configuration(config_path)
-    save_config(config_path, config)
-    display_message(f"LLM '{llm_name}' has been removed.", "info")
-    logger.info(f"Removed LLM '{llm_name}' from configuration.")
-
-def add_mcp_server(config_path: str) -> None:
-    """
-    Add a new MCP server to the configuration.
-
-    Args:
-        config_path (str): Path to the configuration file.
-    """
-    config = load_config(config_path)
-    display_message("Starting the process to add a new MCP server.", "info")
-
-    while True:
-        server_name = prompt_user("Enter the name of the new MCP server (or type 'done' to finish)").strip()
-        display_message(f"User entered MCP server name: {server_name}", "info")
-        if server_name.lower() == 'done':
-            display_message("Finished adding MCP servers.", "info")
-            break
-        if not server_name:
-            display_message("Server name cannot be empty.", "error")
-            continue
-
-        if server_name in config.get("mcpServers", {}):
-            display_message(f"MCP server '{server_name}' already exists.", "warning")
-            continue
-
-        server = {}
-        server["command"] = prompt_user("Enter the command to run the MCP server (e.g., 'npx', 'uvx')").strip()
-        args_input = prompt_user("Enter the arguments as a JSON array (e.g., [\"-y\", \"server-name\"])").strip()
-        try:
-            server["args"] = json.loads(args_input)
-            if not isinstance(server["args"], list):
-                raise ValueError
-        except ValueError:
-            display_message("Invalid arguments format. Using an empty list.", "warning")
-            server["args"] = []
-
-        env_vars = {}
-        add_env = prompt_user("Do you want to add environment variables? (yes/no)").strip().lower()
-        while add_env in ['yes', 'y']:
-            env_var = prompt_user("Enter the environment variable name").strip()
-            env_value = prompt_user(f"Enter the value or placeholder for '{env_var}' (e.g., '${{{env_var}_KEY}}')").strip()
-            if env_var and env_value:
-                env_vars[env_var] = env_value
-            add_env = prompt_user("Add another environment variable? (yes/no)").strip().lower()
-
-        server["env"] = env_vars
-
-        config.setdefault("mcpServers", {})[server_name] = server
-        logger.info(f"Added MCP server '{server_name}' to configuration.")
-        display_message(f"MCP server '{server_name}' added.", "info")
-
-    backup_configuration(config_path)
-    save_config(config_path, config)
-    display_message("MCP server configuration process completed.", "info")
-
-def remove_mcp_server(config_path: str, server_name: str) -> None:
-    """
-    Remove an existing MCP server from the configuration.
-
-    Args:
-        config_path (str): Path to the configuration file.
-        server_name (str): Name of the MCP server to remove.
-    """
-    config = load_config(config_path)
-
-    if server_name not in config.get("mcpServers", {}):
-        display_message(f"MCP server '{server_name}' does not exist.", "error")
-        return
-
-    confirm = prompt_user(f"Are you sure you want to remove MCP server '{server_name}'? (yes/no)").strip().lower()
-    if confirm not in ['yes', 'y']:
-        display_message("Operation cancelled.", "warning")
-        return
-
-    del config["mcpServers"][server_name]
-    backup_configuration(config_path)
-    save_config(config_path, config)
-    display_message(f"MCP server '{server_name}' has been removed.", "info")
-    logger.info(f"Removed MCP server '{server_name}' from configuration.")

swarm/extensions/config/server_config.py

@@ -1,49 +0,0 @@
-"""
-Module for managing server configuration files, including saving and validation.
-
-Provides utilities to save configurations to disk and ensure integrity of data.
-"""
-
-import json
-import os
-import logging
-from swarm.utils.redact import redact_sensitive_data
-
-# Initialize logger for this module
-logger = logging.getLogger(__name__)
-DEBUG = os.getenv("DEBUG", "False").lower() in ("true", "1", "t")  # Define DEBUG locally
-logger.setLevel(logging.DEBUG if DEBUG else logging.INFO)
-stream_handler = logging.StreamHandler()
-formatter = logging.Formatter("[%(levelname)s] %(asctime)s - %(name)s - %(message)s")
-stream_handler.setFormatter(formatter)
-if not logger.handlers:
-    logger.addHandler(stream_handler)
-
-def save_server_config(config: dict, file_path: str = None) -> None:
-    """
-    Saves the server configuration to a JSON file.
-
-    Args:
-        config (dict): The configuration dictionary to save.
-        file_path (str): The path to save the configuration file. Defaults to 'swarm_settings.json' in the current directory.
-
-    Raises:
-        ValueError: If the configuration is not a valid dictionary.
-        OSError: If there are issues writing to the file.
-    """
-    if not isinstance(config, dict):
-        logger.error("Provided configuration is not a dictionary.")
-        raise ValueError("Configuration must be a dictionary.")
-
-    if file_path is None:
-        file_path = os.path.join(os.getcwd(), "swarm_settings.json")
-
-    logger.debug(f"Saving server configuration to {file_path}")
-    try:
-        with open(file_path, "w") as file:
-            json.dump(config, file, indent=4)
-            logger.info(f"Configuration successfully saved to {file_path}")
-            logger.debug(f"Saved configuration: {redact_sensitive_data(config)}")
-    except OSError as e:
-        logger.error(f"Error saving configuration to {file_path}: {e}")
-        raise