open-swarm 0.1.1745275181__py3-none-any.whl → 0.1.1748636259__py3-none-any.whl

swarm/core/blueprint_discovery.py

@@ -1,125 +0,0 @@
-import os
-import importlib
-import importlib.util
-import inspect
-import logging # Ensure logging is imported
-import sys
-from typing import Dict, Type, Any
-from pathlib import Path
-
-# *** Define logger EARLIER ***
-logger = logging.getLogger(__name__)
-
-# *** Import the ACTUAL BlueprintBase from the likely correct path ***
-try:
-    # Adjust this path if BlueprintBase lives elsewhere
-    from swarm.core.blueprint_base import BlueprintBase
-except ImportError:
-    # This logger call is now safe
-    logger.error("Failed to import BlueprintBase from swarm.core.blueprint_base. Using placeholder.", exc_info=True)
-    # REMOVED DUMMY BlueprintBase to prevent MRO/import bugs. Always import BlueprintBase from swarm.core.blueprint_base
-
-
-class BlueprintLoadError(Exception):
-    """Custom exception for errors during blueprint loading."""
-    pass
-
-def _get_blueprint_name_from_dir(dir_name: str) -> str:
-    """Converts directory name (e.g., 'blueprint_my_agent') to blueprint name (e.g., 'my_agent')."""
-    prefix = "blueprint_"
-    if dir_name.startswith(prefix):
-        return dir_name[len(prefix):]
-    return dir_name
-
-def discover_blueprints(blueprint_dir: str) -> Dict[str, Type[BlueprintBase]]:
-    """
-    Discovers blueprints (subclasses of BlueprintBase) by looking for
-    'blueprint_{name}.py' files within subdirectories of the given blueprint directory.
-
-    Args:
-        blueprint_dir: The path to the directory containing blueprint subdirectories.
-
-    Returns:
-        A dictionary mapping blueprint names to their corresponding class objects.
-    """
-    logger.info(f"Starting blueprint discovery in directory: {blueprint_dir}")
-    blueprints: Dict[str, Type[BlueprintBase]] = {}
-    base_dir = Path(blueprint_dir).resolve()
-
-    if not base_dir.is_dir():
-        logger.error(f"Blueprint directory not found or is not a directory: {base_dir}")
-        return blueprints
-
-    # Iterate over items inside the base blueprint directory
-    for subdir in base_dir.iterdir():
-        if not subdir.is_dir():
-            continue # Skip files directly under blueprints/
-
-        # Use directory name as blueprint name (e.g., 'echocraft')
-        blueprint_name = subdir.name
-        logger.debug(f"Processing potential blueprint '{blueprint_name}' in directory: {subdir.name}")
-
-        # Look for the specific .py file, e.g., blueprint_echocraft.py
-        py_file_name = f"blueprint_{blueprint_name}.py"
-        py_file_path = subdir / py_file_name
-
-        if not py_file_path.is_file():
-            # Also check for just {blueprint_name}.py if that's a convention
-            alt_py_file_name = f"{blueprint_name}.py"
-            alt_py_file_path = subdir / alt_py_file_name
-            if alt_py_file_path.is_file():
-                 py_file_path = alt_py_file_path # Use the alternative path
-                 py_file_name = alt_py_file_name
-                 logger.debug(f"Found alternative blueprint file: {py_file_name}")
-            else:
-                 logger.warning(f"Skipping directory '{subdir.name}': Neither '{py_file_name}' nor '{alt_py_file_name}' found.")
-                 continue
-
-
-        # Construct module import path, e.g., blueprints.echocraft.blueprint_echocraft
-        if py_file_path.name.startswith('blueprint_gatcha'):
-            module_import_path = f"swarm.blueprints.gatcha.{py_file_path.stem}"
-        elif py_file_path.name.startswith('blueprint_'):
-            module_import_path = f"swarm.blueprints.{subdir.name}.{py_file_path.stem}"
-        else:
-            continue
-
-        try:
-            # Ensure parent directory is in path
-            parent_dir = str(base_dir.parent)
-            if parent_dir not in sys.path:
-                 logger.debug(f"Adding '{parent_dir}' to sys.path for blueprint discovery.")
-                 sys.path.insert(0, parent_dir)
-
-            # Create module spec from file path
-            module_spec = importlib.util.spec_from_file_location(module_import_path, py_file_path)
-
-            if module_spec and module_spec.loader:
-                module = importlib.util.module_from_spec(module_spec)
-                sys.modules[module_import_path] = module
-                module_spec.loader.exec_module(module)
-                logger.debug(f"Successfully loaded module: {module_import_path}")
-
-                found_bp_class = None
-                for name, obj in inspect.getmembers(module):
-                    if inspect.isclass(obj) and obj.__module__ == module_import_path and issubclass(obj, BlueprintBase) and obj is not BlueprintBase:
-                        if found_bp_class:
-                            logger.warning(f"Multiple BlueprintBase subclasses found in {py_file_name}. Using the first: {found_bp_class.__name__}.")
-                        else:
-                            logger.debug(f"Found Blueprint class '{name}' in module '{module_import_path}'")
-                            found_bp_class = obj
-                            blueprints[blueprint_name] = found_bp_class
-                            # break
-
-                if not found_bp_class:
-                    logger.warning(f"No BlueprintBase subclass found directly defined in module: {module_import_path}")
-            else:
-                logger.warning(f"Could not create module spec for {py_file_path}")
-
-        except Exception as e:
-            logger.error(f"Error processing blueprint file '{py_file_path}': {e}", exc_info=True)
-            if module_import_path in sys.modules:
-                 del sys.modules[module_import_path]
-
-    logger.info(f"Blueprint discovery complete. Found: {list(blueprints.keys())}")
-    return blueprints

swarm/core/blueprint_runner.py

@@ -1,59 +0,0 @@
-import sys
-import traceback
-import types
-from typing import AsyncGenerator
-import inspect
-
-from .blueprint_base import Spinner
-
-class BlueprintRunner:
-    @staticmethod
-    async def run_agent(agent, instruction, filter_llm_function_calls=True, spinner_enabled=True) -> AsyncGenerator[dict, None]:
-        """
-        Runs the agent using Runner.run as an async generator or coroutine, with spinner and error handling.
-        Filters out LLM function call outputs if requested.
-        Handles both coroutine and async generator return types.
-        """
-        from agents import Runner
-        # Only enable spinner if spinner_enabled is True and not in non-interactive mode
-        # (i.e., only if show_intermediate is True)
-        spinner = None
-        if spinner_enabled:
-            # Check for a marker in instruction or a kwarg to disable spinner in non-interactive
-            frame = inspect.currentframe()
-            show_intermediate = False
-            while frame:
-                if 'kwargs' in frame.f_locals and isinstance(frame.f_locals['kwargs'], dict):
-                    show_intermediate = frame.f_locals['kwargs'].get('show_intermediate', False)
-                    break
-                frame = frame.f_back
-            if show_intermediate:
-                spinner = Spinner()
-        try:
-            if spinner:
-                spinner.start()
-            result = await Runner.run(agent, instruction)
-            # If result is an async generator, iterate over it
-            if isinstance(result, types.AsyncGeneratorType):
-                async for chunk in result:
-                    if filter_llm_function_calls:
-                        content = chunk.get("content")
-                        if content and ("function call" in content or "args" in content):
-                            continue
-                    yield chunk
-            elif isinstance(result, (list, dict)):
-                # If it's a list of chunks or a single chunk, yield directly
-                if isinstance(result, list):
-                    for chunk in result:
-                        yield chunk
-                else:
-                    yield result
-            elif result is not None:
-                # Fallback: yield as a single chunk
-                yield {"messages": [{"role": "assistant", "content": str(result)}]}
-        except Exception as e:
-            tb = traceback.format_exc()
-            yield {"messages": [{"role": "assistant", "content": f"Error: {e}\n{tb}"}]}
-        finally:
-            if spinner:
-                spinner.stop()

swarm/core/blueprint_ux.py

@@ -1,109 +0,0 @@
-# UX utilities for Swarm blueprints (stub for legacy/test compatibility)
-
-class BlueprintUX:
-    def __init__(self, style=None):
-        self.style = style or "default"
-    def box(self, title, content, summary=None, params=None):
-        # Minimal ANSI/emoji box for test compatibility
-        box = f"\033[1;36m┏━ {title} ━\033[0m\n"
-        if params:
-            box += f"\033[1;34m┃ Params: {params}\033[0m\n"
-        if summary:
-            box += f"\033[1;33m┃ {summary}\033[0m\n"
-        for line in content.split('\n'):
-            box += f"┃ {line}\n"
-        box += "┗"+"━"*20
-        return box
-
-import time
-import itertools
-
-# Style presets
-
-def get_style(style):
-    if style == "serious":
-        return {
-            "border_top": "\033[1;34m╔" + "═"*50 + "╗\033[0m",
-            "border_bottom": "\033[1;34m╚" + "═"*50 + "╝\033[0m",
-            "border_side": "\033[1;34m║\033[0m",
-            "emoji": "🛠️",
-            "spinner": ['Generating.', 'Generating..', 'Generating...', 'Running...'],
-            "fallback": 'Generating... Taking longer than expected',
-        }
-    elif style == "silly":
-        return {
-            "border_top": "\033[1;35m(ﾉ◕ヮ◕)ﾉ*:･ﾟ✧" + "~"*40 + "✧ﾟ･: *ヽ(◕ヮ◕ヽ)\033[0m",
-            "border_bottom": "\033[1;35m(づ｡◕‿‿◕｡)づ" + "~"*40 + "づ(｡◕‿‿◕｡)づ\033[0m",
-            "border_side": "\033[1;35m~\033[0m",
-            "emoji": "🦆",
-            "spinner": ['Quacking.', 'Quacking..', 'Quacking...', 'Flapping...'],
-            "fallback": 'Quacking... Taking longer than expected',
-        }
-    else:
-        return get_style("serious")
-
-class BlueprintUXImproved:
-    def __init__(self, style="serious"):
-        self.style = style
-        self._style_conf = get_style(style)
-        self._spinner_cycle = itertools.cycle(self._style_conf["spinner"])
-        self._spinner_start = None
-
-    def spinner(self, state_idx, taking_long=False):
-        if taking_long:
-            return self._style_conf["fallback"]
-        spinner_states = self._style_conf["spinner"]
-        return spinner_states[state_idx % len(spinner_states)]
-
-    def summary(self, op_type, result_count, params):
-        # Enhanced: pretty param formatting
-        param_str = ', '.join(f'{k}={v!r}' for k, v in (params or {}).items()) if params else 'None'
-        return f"{op_type} | Results: {result_count} | Params: {param_str}"
-
-    def progress(self, current, total=None):
-        if total:
-            return f"Processed {current}/{total} lines..."
-        return f"Processed {current} lines..."
-
-    def code_vs_semantic(self, result_type, results):
-        if result_type == "code":
-            header = "[Code Search Results]"
-        elif result_type == "semantic":
-            header = "[Semantic Search Results]"
-        else:
-            header = "[Results]"
-        # Enhanced: visually distinct divider
-        divider = "\n" + ("=" * 40) + "\n"
-        return f"{header}{divider}" + "\n".join(results)
-
-    def ansi_emoji_box(self, title, content, summary=None, params=None, result_count=None, op_type=None, style=None, color=None, status=None):
-        """
-        Unified ANSI/emoji box for search/analysis/fileops results.
-        Summarizes: operation, result count, params, and allows for periodic updates.
-        Supports color and status for advanced UX.
-        """
-        style_conf = get_style(style or self.style)
-        # Color/status logic
-        color_map = {
-            "success": "92",  # green
-            "info": "94",     # blue
-            "warning": "93",  # yellow
-            "error": "91",    # red
-            None: "94",         # default blue
-        }
-        ansi_color = color_map.get(status, color_map[None])
-        box = f"\033[{ansi_color}m" + style_conf["border_top"] + "\033[0m\n"
-        box += f"\033[{ansi_color}m{style_conf['border_side']} {style_conf['emoji']} {title}"
-        if op_type:
-            box += f" | {op_type}"
-        if result_count is not None:
-            box += f" | Results: {result_count}"
-        box += "\033[0m\n"
-        if params:
-            box += f"\033[{ansi_color}m{style_conf['border_side']} Params: {params}\033[0m\n"
-        if summary:
-            box += f"\033[{ansi_color}m{style_conf['border_side']} {summary}\033[0m\n"
-        for line in content.split('\n'):
-            box += f"\033[{ansi_color}m{style_conf['border_side']} {line}\033[0m\n"
-        box += f"\033[{ansi_color}m" + style_conf["border_bottom"] + "\033[0m"
-        return box

swarm/core/build_launchers.py

@@ -1,15 +0,0 @@
-#!/usr/bin/env python3
-import PyInstaller.__main__
-
-def build_executable(script, output_name):
-    PyInstaller.__main__.run([
-        script,
-        "--onefile",
-        "--name", output_name,
-    ])
-
-if __name__ == "__main__":
-    # build echocraft first (already done), now build rue_code
-    build_executable("src/swarm/blueprints/rue_code/blueprint_rue_code.py", "ruecode-blueprint")
-    # Uncomment below to build suggestion after verifying disk space
-    # build_executable("src/swarm/blueprints/suggestion/blueprint_suggestion.py", "suggestion-blueprint")

swarm/core/cli/__init__.py

@@ -1 +0,0 @@
-

swarm/core/cli/commands/__init__.py

@@ -1 +0,0 @@
-

swarm/core/cli/commands/blueprint_management.py

@@ -1,7 +0,0 @@
-from swarm.core.blueprint_utils import list_blueprints
-
-def execute():
-    """Manage blueprints (list, add, remove, etc)."""
-    print("Blueprints:")
-    for bp in list_blueprints():
-        print(f"- {bp}")

swarm/core/cli/interactive_shell.py

@@ -1,14 +0,0 @@
-def interactive_shell():
-    print("Welcome to Swarm Core CLI Interactive Shell!")
-    print("Type 'help' for available commands.")
-    while True:
-        try:
-            cmd = input("swarm> ").strip()
-            if cmd in ("exit", "quit"): break
-            elif cmd == "help":
-                print("Available commands: list, edit-config, validate-env, validate-envvars, blueprint-manage, config-manage")
-            elif cmd:
-                print(f"Command '{cmd}' not recognized (type 'help').")
-        except KeyboardInterrupt:
-            print("\nExiting shell.")
-            break

swarm/core/cli/main.py

@@ -1,50 +0,0 @@
-"""
-Main entry point for Swarm CLI (core).
-"""
-
-import argparse
-import os
-from swarm.core.cli.utils.discover_commands import discover_commands
-from swarm.core.cli.interactive_shell import interactive_shell
-
-COMMANDS_DIR = os.path.join(os.path.dirname(__file__), "commands")
-
-USER_FRIENDLY_COMMANDS = {
-    "list": "list_blueprints",
-    "edit-config": "edit_config",
-    "validate-env": "validate_env",
-    "validate-envvars": "validate_envvars",
-    "blueprint-manage": "blueprint_management",
-    "config-manage": "config_management",
-}
-
-def parse_args(commands):
-    """Parse CLI arguments dynamically with user-friendly names."""
-    parser = argparse.ArgumentParser(description="Swarm CLI Utility (core)")
-    subparsers = parser.add_subparsers(dest="command")
-
-    for cmd_name, metadata in commands.items():
-        subparsers.add_parser(cmd_name, help=metadata["description"])
-
-    return parser.parse_args()
-
-def main():
-    # Discover commands using user-friendly mapping
-    raw_commands = discover_commands(COMMANDS_DIR)
-    commands = {}
-    for user_cmd, internal_cmd in USER_FRIENDLY_COMMANDS.items():
-        if internal_cmd in raw_commands:
-            commands[user_cmd] = raw_commands[internal_cmd]
-    args = parse_args(commands)
-
-    if args.command:
-        command = commands.get(args.command, {}).get("execute")
-        if command:
-            command()
-        else:
-            print(f"Command '{args.command}' is not executable.")
-    else:
-        interactive_shell()
-
-if __name__ == "__main__":
-    main()

swarm/core/cli/utils/__init__.py

@@ -1 +0,0 @@
-

swarm/core/cli/utils/discover_commands.py

@@ -1,18 +0,0 @@
-import os
-import importlib.util
-import inspect
-
-def discover_commands(commands_dir):
-    commands = {}
-    for filename in os.listdir(commands_dir):
-        if filename.endswith('.py') and not filename.startswith('__'):
-            module_name = filename[:-3]
-            module_path = os.path.join(commands_dir, filename)
-            spec = importlib.util.spec_from_file_location(f'swarm.core.cli.commands.{module_name}', module_path)
-            module = importlib.util.module_from_spec(spec)
-            spec.loader.exec_module(module)
-            # Look for an 'execute' function
-            if hasattr(module, 'execute'):
-                desc = inspect.getdoc(module.execute) or f"Run {module_name} command."
-                commands[module_name] = {"execute": module.execute, "description": desc}
-    return commands

swarm/core/config_loader.py

@@ -1,122 +0,0 @@
-import json
-import logging
-import os
-from pathlib import Path
-from typing import Any, Dict, Optional, Union
-
-from dotenv import load_dotenv
-
-logger = logging.getLogger("swarm.config")
-
-def _substitute_env_vars(value: Any) -> Any:
-    import os
-    if isinstance(value, str):
-        # Always expand env vars in any string
-        return os.path.expandvars(value)
-    elif isinstance(value, list):
-        return [_substitute_env_vars(item) for item in value]
-    elif isinstance(value, dict):
-        return {k: _substitute_env_vars(v) for k, v in value.items()}
-    return value
-
-def load_environment(project_root: Path):
-    """Loads environment variables from a `.env` file located at the project root."""
-    dotenv_path = project_root / ".env"
-    logger.debug(f"Checking for .env file at: {dotenv_path}")
-    try:
-        if dotenv_path.is_file():
-            loaded = load_dotenv(dotenv_path=dotenv_path, override=True)
-            if loaded:
-                logger.debug(f".env file Loaded/Overridden at: {dotenv_path}")
-        else:
-            logger.debug(f"No .env file found at {dotenv_path}.")
-    except Exception as e:
-        logger.error(f"Error loading .env file '{dotenv_path}': {e}", exc_info=logger.level <= logging.DEBUG)
-
-def load_full_configuration(
-    blueprint_class_name: str,
-    default_config_path: Path,
-    config_path_override: Optional[Union[str, Path]] = None,
-    profile_override: Optional[str] = None,
-    cli_config_overrides: Optional[Dict[str, Any]] = None,
-) -> Dict[str, Any]:
-    """
-    Loads and merges configuration settings from base file, blueprint specifics, profiles, and CLI overrides.
-
-    Args:
-        blueprint_class_name (str): The name of the blueprint class (e.g., "MyBlueprint").
-        default_config_path (Path): The default path to the swarm_config.json file.
-        config_path_override (Optional[Union[str, Path]]): Path specified via CLI argument.
-        profile_override (Optional[str]): Profile specified via CLI argument.
-        cli_config_overrides (Optional[Dict[str, Any]]): Overrides provided via CLI argument.
-
-    Returns:
-        Dict[str, Any]: The final, merged configuration dictionary.
-
-    Raises:
-        ValueError: If the configuration file has JSON errors or cannot be read.
-        FileNotFoundError: If a specific config_path_override is given but the file doesn't exist.
-    """
-    config_path = Path(config_path_override) if config_path_override else default_config_path
-    logger.debug(f"Attempting to load base configuration from: {config_path}")
-    base_config = {}
-    if config_path.is_file():
-        try:
-            with open(config_path, "r", encoding="utf-8") as f:
-                base_config = json.load(f)
-            logger.debug(f"Successfully loaded base configuration from: {config_path}")
-        except json.JSONDecodeError as e:
-            raise ValueError(f"Config Error: Failed to parse JSON in {config_path}: {e}") from e
-        except Exception as e:
-            raise ValueError(f"Config Error: Failed to read {config_path}: {e}") from e
-    else:
-        if config_path_override:
-            raise FileNotFoundError(f"Configuration Error: Specified config file not found: {config_path}")
-        else:
-            logger.warning(f"Default configuration file not found at {config_path}. Proceeding without base configuration.")
-
-    # 1. Start with base defaults
-    final_config = base_config.get("defaults", {}).copy()
-    logger.debug(f"Applied base defaults. Keys: {list(final_config.keys())}")
-
-    # 2. Merge base llm and mcpServers sections
-    if "llm" in base_config:
-        final_config.setdefault("llm", {}).update(base_config["llm"])
-        logger.debug("Merged base 'llm'.")
-    if "mcpServers" in base_config:
-        final_config.setdefault("mcpServers", {}).update(base_config["mcpServers"])
-        logger.debug("Merged base 'mcpServers'.")
-
-    # 3. Merge blueprint-specific settings
-    blueprint_settings = base_config.get("blueprints", {}).get(blueprint_class_name, {})
-    if blueprint_settings:
-        final_config.update(blueprint_settings)
-        logger.debug(f"Merged BP '{blueprint_class_name}' settings. Keys: {list(blueprint_settings.keys())}")
-
-    # 4. Determine and merge profile settings
-    # Priority: CLI > Blueprint Specific > Base Defaults > "default"
-    profile_in_bp_settings = blueprint_settings.get("default_profile")
-    profile_in_base_defaults = base_config.get("defaults", {}).get("default_profile")
-    profile_to_use = profile_override or profile_in_bp_settings or profile_in_base_defaults or "default"
-    logger.debug(f"Using profile: '{profile_to_use}'")
-    profile_settings = base_config.get("profiles", {}).get(profile_to_use, {})
-    if profile_settings:
-        final_config.update(profile_settings)
-        logger.debug(f"Merged profile '{profile_to_use}'. Keys: {list(profile_settings.keys())}")
-    elif profile_to_use != "default" and (profile_override or profile_in_bp_settings or profile_in_base_defaults):
-        logger.warning(f"Profile '{profile_to_use}' requested but not found.")
-
-    # 5. Merge CLI overrides (highest priority)
-    if cli_config_overrides:
-        final_config.update(cli_config_overrides)
-        logger.debug(f"Merged CLI overrides. Keys: {list(cli_config_overrides.keys())}")
-
-    # Ensure top-level keys exist
-    final_config.setdefault("llm", {})
-    final_config.setdefault("mcpServers", {})
-
-    # 6. Substitute environment variables in the final config
-    final_config = _substitute_env_vars(final_config)
-    logger.debug("Applied final env var substitution.")
-
-    return final_config