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

swarm/{core → extensions/blueprint}/spinner.py

@@ -6,36 +6,29 @@ 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...']
-    }
+    # SPINNER_CHARS = ['|', '/', '-', '\\'] # Simpler alternative
 
-    def __init__(self, interactive: bool, custom_sequence: str = None):
+    def __init__(self, interactive: bool):
         """
         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
+        # Check if output is a TTY (terminal) and interactive flag is True
         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."""
@@ -43,7 +36,7 @@ class Spinner:
             return # Do nothing if disabled or already running
         self.status = status
         self.running = True
-        self.sequence_idx = 0
+        # Run the spinner animation in a separate daemon thread
         self.thread = threading.Thread(target=self._spin, daemon=True)
         self.thread.start()
 
@@ -54,33 +47,30 @@ class Spinner:
         self.running = False
         if self.thread is not None:
             self.thread.join() # Wait for the thread to finish
+        # Clear the spinner line using ANSI escape codes
+        # \r: Carriage return (move cursor to beginning of line)
+        # \033[K: Clear line from cursor to end
         sys.stdout.write("\r\033[K")
         sys.stdout.flush()
-        self.thread = None
+        self.thread = None # Reset thread
 
     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)]
+            # Get the next spinner character
+            char = self.SPINNER_CHARS[self.index % len(self.SPINNER_CHARS)]
+            # Write spinner char and status, overwrite previous line content
+            try:
+                # \r moves cursor to beginning, \033[K clears the rest of the line
                 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)
+            except BlockingIOError:
+                 # Handle potential issues if stdout is blocked (less likely for TTY)
+                 time.sleep(0.1)
+                 continue
+            self.index += 1
+            # Pause for animation effect
+            time.sleep(0.1)
 
 # Example usage (if run directly)
 if __name__ == "__main__":
@@ -98,3 +88,4 @@ if __name__ == "__main__":
     finally:
         s.stop() # Ensure spinner stops on exit/error
         print("Test finished.")
+

swarm/extensions/cli/cli_args.py

@@ -1,14 +1,8 @@
 # src/swarm/extensions/blueprint/modes/cli_mode/cli_args.py
 
 import argparse
-import os
-import sys
 from typing import Namespace
 
-# --- DEBUG PRINTS REMOVED BY CASCADE ---
-# print(f"[DEBUG] cli_args.py startup: sys.argv={sys.argv}")
-# print(f"[DEBUG] cli_args.py startup: LITELLM_MODEL={os.environ.get('LITELLM_MODEL')}, DEFAULT_LLM={os.environ.get('DEFAULT_LLM')}")
-
 def parse_arguments() -> Namespace:
     """
     Parse command-line arguments for dynamic LLM configuration, MCP server management, and other overrides.

swarm/extensions/cli/commands/blueprint_management.py

@@ -1,7 +1,7 @@
 # Handles blueprint discovery and validation for the CLI
 
-from swarm.core.blueprint_discovery import discover_blueprints
-# from swarm.core.config_loader import load_server_config  # Removed: function does not exist
+from swarm.extensions.blueprint.discovery import discover_blueprints
+from swarm.extensions.config.config_loader import load_server_config
 
 def list_blueprints():
     """List available blueprints and their metadata."""
@@ -13,57 +13,19 @@ def list_blueprints():
     for name, metadata in blueprints.items():
         print(f"- {name}: {metadata.get('description', 'No description available.')}")
 
-def enable_blueprint(blueprint_name):
-    """
-    Enable a blueprint by adding it to config and creating a CLI symlink.
-    """
-    import json
-    import os
-    from pathlib import Path
-    CONFIG_PATH = os.path.expanduser("~/.config/swarm/swarm_config.json")
-    BIN_DIR = os.path.expanduser("~/.local/bin")
-    BP_RUNNER = os.path.join(os.path.dirname(__file__), "../../../../src/swarm/blueprints/{}/blueprint_{}.py".format(blueprint_name, blueprint_name))
-    CLI_SYMLINK = os.path.join(BIN_DIR, blueprint_name)
-
-    # Load config
-    with open(CONFIG_PATH, "r") as f:
-        config = json.load(f)
-    enabled = config.get("blueprints", {}).get("enabled", [])
-    if blueprint_name in enabled:
-        print(f"Blueprint '{blueprint_name}' is already enabled.")
-        return
-    # Add to config
-    enabled.append(blueprint_name)
-    if "blueprints" not in config:
-        config["blueprints"] = {}
-    config["blueprints"]["enabled"] = enabled
-    with open(CONFIG_PATH, "w") as f:
-        json.dump(config, f, indent=2)
-    # Ensure bin dir exists
-    os.makedirs(BIN_DIR, exist_ok=True)
-    # Create symlink (Python runner)
-    if not os.path.isfile(BP_RUNNER):
-        print(f"Blueprint runner not found: {BP_RUNNER}")
-        return
-    # Write a .sh launcher wrapper for .py if not present
-    CLI_WRAPPER = CLI_SYMLINK
-    with open(CLI_WRAPPER, "w") as f:
-        f.write(f"#!/usr/bin/env bash\nexec python3 '{os.path.abspath(BP_RUNNER)}' \"$@\"")
-    os.chmod(CLI_WRAPPER, 0o755)
-    print(f"Enabled blueprint '{blueprint_name}'. CLI utility installed at {CLI_WRAPPER}.")
-
+cat > src/swarm/extensions/cli/commands/config_management.py << 'EOF'
 # Handles configuration management workflows (e.g., LLM, MCP servers)
 
-# from swarm.core.config_loader import (
-#     load_server_config,
-#     save_server_config,
-# )
+from swarm.extensions.config.config_loader import (
+    load_server_config,
+    save_server_config,
+)
 
 def add_llm(model_name, api_key):
     """Add a new LLM configuration."""
-    config = {}  # load_server_config()
+    config = load_server_config()
     if "llms" not in config:
         config["llms"] = {}
     config["llms"][model_name] = {"api_key": api_key}
-    # save_server_config(config)
+    save_server_config(config)
     print(f"Added LLM '{model_name}' to configuration.")

swarm/extensions/cli/commands/config_management.py

@@ -1,14 +1,15 @@
 # Handles configuration management workflows (e.g., LLM, MCP servers)
 
-from swarm.core import config_loader
-from swarm.core import config_manager
-from swarm.core import server_config
+from swarm.extensions.config.config_loader import (
+    load_server_config,
+    save_server_config,
+)
 
 def add_llm(model_name, api_key):
     """Add a new LLM configuration."""
-    config = config_loader.load_server_config()
+    config = load_server_config()
     if "llms" not in config:
         config["llms"] = {}
     config["llms"][model_name] = {"api_key": api_key}
-    config_manager.save_server_config(config)
+    save_server_config(config)
     print(f"Added LLM '{model_name}' to configuration.")

swarm/extensions/cli/commands/edit_config.py

@@ -1,21 +1,12 @@
 import argparse
 import json
-from swarm.core import (
-    config_loader,
-    config_manager,
-    server_config,
-    setup_wizard,
+from swarm.extensions.config.config_loader import (
+    load_server_config,
+    save_server_config,
 )
 from pathlib import Path
-import os
 
-def get_xdg_config_path():
-    config_home = os.environ.get("XDG_CONFIG_HOME", str(Path.home() / ".config"))
-    config_dir = Path(config_home) / "swarm"
-    config_dir.mkdir(parents=True, exist_ok=True)
-    return config_dir / "swarm_config.json"
-
-CONFIG_PATH = get_xdg_config_path()
+CONFIG_PATH = Path("swarm_config.json").resolve()
 
 def list_config(config):
     """
@@ -69,7 +60,7 @@ def main():
     args = parser.parse_args()
 
     try:
-        config = config_loader.load_server_config(str(CONFIG_PATH))
+        config = load_server_config(str(CONFIG_PATH))
     except FileNotFoundError as e:
         print(f"Error: {e}")
         return
@@ -78,9 +69,9 @@ def main():
         list_config(config)
     elif args.interactive:
         edit_config_interactive(config)
-        config_loader.save_server_config(str(CONFIG_PATH), config)
+        save_server_config(str(CONFIG_PATH), config)
     elif args.field and args.value:
         edit_config_field(config, args.field, args.value)
-        config_loader.save_server_config(str(CONFIG_PATH), config)
+        save_server_config(str(CONFIG_PATH), config)
     else:
         parser.print_help()

swarm/extensions/cli/commands/list_blueprints.py

@@ -4,7 +4,7 @@ Description: Lists all blueprints available in the system.
 """
 
 from pathlib import Path
-from swarm.core.blueprint_discovery import discover_blueprints
+from swarm.extensions.blueprint.blueprint_discovery import discover_blueprints
 
 # Metadata for dynamic registration
 description = "Lists all blueprints available in the system."

swarm/extensions/cli/commands/validate_env.py

@@ -1,16 +1,9 @@
 import os
 import argparse
-from pathlib import Path
-from swarm.core import config_loader, config_manager, server_config
-from swarm.core.blueprint_base import BlueprintBase
+from swarm.extensions.config.config_loader import load_server_config
+from swarm.extensions.blueprint.blueprint_base import BlueprintBase
 
-def get_xdg_config_path():
-    config_home = os.environ.get("XDG_CONFIG_HOME", str(Path.home() / ".config"))
-    config_dir = Path(config_home) / "swarm"
-    config_dir.mkdir(parents=True, exist_ok=True)
-    return config_dir / "swarm_config.json"
-
-CONFIG_PATH = str(get_xdg_config_path())
+CONFIG_PATH = "swarm_config.json"
 
 def validate_all_env_vars(config):
     """
@@ -50,7 +43,7 @@ def main():
     args = parser.parse_args()
 
     try:
-        config = server_config.load_server_config(CONFIG_PATH)
+        config = load_server_config(CONFIG_PATH)
     except FileNotFoundError as e:
         print(f"Error: {e}")
         return

swarm/extensions/cli/commands/validate_envvars.py

@@ -1,5 +1,5 @@
-from swarm.core.blueprint_discovery import discover_blueprints
-from swarm.core import config_loader, config_manager, server_config
+from swarm.extensions.blueprint.blueprint_discovery import discover_blueprints
+from swarm.extensions.config.config_loader import load_env_config, validate_env_vars
 import argparse
 
 def validate_envvars(blueprint_name=None):
@@ -19,16 +19,16 @@ def validate_envvars(blueprint_name=None):
             print(f"Blueprint '{blueprint_name}' not found.")
             return
         required_vars = blueprint.get("env_vars", [])
-        env_vars = config_loader.load_env_config()
-        validation = config_manager.validate_env_vars(env_vars, required_vars)
+        env_vars = load_env_config()
+        validation = validate_env_vars(env_vars, required_vars)
         print(f"Validation for '{blueprint_name}': {validation}")
     else:
         # Global validation
-        env_vars = config_loader.load_env_config()
+        env_vars = load_env_config()
         print("Global Environment Validation:")
         for blueprint_name, blueprint_data in blueprints.items():
             required_vars = blueprint_data.get("env_vars", [])
-            validation = config_manager.validate_env_vars(env_vars, required_vars)
+            validation = validate_env_vars(env_vars, required_vars)
             print(f"Validation for '{blueprint_name}': {validation}")
 
 def main():

swarm/extensions/cli/interactive_shell.py

@@ -35,21 +35,7 @@ def interactive_shell():
             break
 
 def show_help(commands):
-    """Display available commands with helpful context and usage."""
-    print("\n\033[1;36mSwarm CLI Help\033[0m")
-    print("Type the command name to run it, or 'exit' to quit.")
-    print("Commands can be used to manage your Swarm config, blueprints, LLMs, MCP servers, and more.\n")
+    """Display available commands."""
     print("Available commands:")
     for cmd, metadata in commands.items():
-        desc = metadata.get('description', 'No description provided.')
-        usage = metadata.get('usage', None)
-        print(f"  \033[1;33m{cmd}\033[0m: {desc}")
-        if usage:
-            print(f"    Usage: {usage}")
-    print("\nExamples:")
-    print("  validate_envvars    # Check required environment variables")
-    print("  edit_config         # Edit your Swarm config interactively")
-    print("  list_blueprints     # List all available blueprints")
-    print("  blueprint_management # Advanced blueprint management")
-    print("  config_management   # Manage LLMs, MCP servers, blueprints")
-    print("\nType 'exit' to leave the shell.\n")
+        print(f" - {cmd}: {metadata['description']}")