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

swarm/core/output_utils.py

@@ -1,193 +0,0 @@
-"""
-Output utilities for Swarm blueprints.
-"""
-
-import json
-import logging
-import os
-import sys
-from typing import List, Dict, Any
-import re
-
-# 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, agent_name: str = None) -> None:
-    """Format and print messages, optionally rendering assistant content as markdown, and always prefixing agent responses with the agent's name."""
-    # --- DEBUG PRINT ---
-    print(f"\n[DEBUG pretty_print_response called with {len(messages)} messages, use_markdown={use_markdown}, agent_name={agent_name}]", 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":
-            # Use agent_name if provided, else sender, else 'assistant'
-            display_name = agent_name or sender or "assistant"
-            # Magenta for agent output
-            print(f"\033[95m[{display_name}]\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)
-                # --- CODE FENCE HIGHLIGHTING ---
-                if RICH_AVAILABLE and '```' in msg_content:
-                    import re
-                    code_fence_pattern = r"```([\w\d]*)\n([\s\S]*?)```"
-                    matches = re.findall(code_fence_pattern, msg_content)
-                    if matches:
-                        from rich.syntax import Syntax
-                        from rich.console import Console
-                        console = Console()
-                        for lang, code in matches:
-                            syntax = Syntax(code, lang or "python", theme="monokai", line_numbers=False)
-                            console.print(syntax)
-                        # Optionally print any non-code parts
-                        non_code = re.split(code_fence_pattern, msg_content)
-                        for i, part in enumerate(non_code):
-                            if i % 3 == 0 and part.strip():
-                                print(part.strip(), flush=True)
-                    else:
-                        print(msg_content, flush=True)
-                elif use_markdown and RICH_AVAILABLE:
-                    render_markdown(msg_content)
-                else:
-                    print(msg_content, flush=True)
-            elif not tool_calls:
-                print(flush=True)
-
-            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/core/session_logger.py

@@ -1,42 +0,0 @@
-import os
-import datetime
-from typing import Optional, List, Dict
-
-class SessionLogger:
-    def __init__(self, blueprint_name: str, log_dir: Optional[str] = None):
-        if log_dir is None:
-            base_dir = os.path.dirname(__file__)
-            log_dir = os.path.join(base_dir, f"../blueprints/{blueprint_name}/session_logs")
-        os.makedirs(log_dir, exist_ok=True)
-        self.log_dir = log_dir
-        self.session_time = datetime.datetime.now().strftime("%Y-%m-%dT%H-%M-%S")
-        self.log_path = os.path.join(log_dir, f"session_{self.session_time}.md")
-        self._open_log()
-
-    def _open_log(self):
-        self.log_file = open(self.log_path, "w")
-        self.log_file.write(f"# Session Log\n\nStarted: {self.session_time}\n\n")
-        self.log_file.flush()
-
-    def log_instructions(self, global_instructions: Optional[str], project_instructions: Optional[str]):
-        self.log_file.write("## Instructions\n")
-        if global_instructions:
-            self.log_file.write("### Global Instructions\n" + global_instructions + "\n\n")
-        if project_instructions:
-            self.log_file.write("### Project Instructions\n" + project_instructions + "\n\n")
-        self.log_file.write("## Messages\n")
-        self.log_file.flush()
-
-    def log_message(self, role: str, content: str, agent_name: str = None):
-        # Log agent name if provided, else fallback to role
-        display_name = agent_name or role
-        self.log_file.write(f"- **{display_name}**: {content}\n")
-        self.log_file.flush()
-
-    def log_tool_call(self, tool_name: str, result: str):
-        self.log_file.write(f"- **assistant (tool:{tool_name})**: {result}\n")
-        self.log_file.flush()
-
-    def close(self):
-        self.log_file.write(f"\nEnded: {datetime.datetime.now().strftime('%Y-%m-%dT%H-%M-%S')}\n")
-        self.log_file.close()

swarm/core/slash_commands.py

@@ -1,89 +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()
-# Built-in '/help' slash command
-@slash_registry.register('/help')
-def _help_command(blueprint=None, args=None):
-    """List available slash commands."""
-    cmds = sorted(slash_registry.commands.keys())
-    return "Available slash commands:\n" + "\n".join(cmds)
-
-# Built-in '/compact' slash command
-@slash_registry.register('/compact')
-def _compact_command(blueprint=None, args=None):
-    """Placeholder for compacting conversation context."""
-    return "[slash command] compact summary not implemented yet."
-
-# Built-in '/model' slash command
-@slash_registry.register('/model')
-def _model_command(blueprint=None, args=None):
-    """
-    /model                   Show current default and overrides
-    /model <profile>         Set session default LLM profile
-    /model <agent> <profile> Override model profile for specific agent
-    """
-    # Sanity: blueprint must be provided
-    if blueprint is None:
-        return "No blueprint context available."
-    profiles = list(blueprint.config.get('llm', {}).keys())
-    # No args: list current settings
-    if not args:
-        lines = [f"Session default: {blueprint._session_model_profile}"]
-        for agent, prof in blueprint._agent_model_overrides.items():
-            lines.append(f"Agent {agent}: {prof}")
-        lines.append("Available profiles: " + ", ".join(profiles))
-        return lines
-    parts = args.split()
-    # Set session default
-    if len(parts) == 1:
-        prof = parts[0]
-        if prof not in profiles:
-            return f"Unknown profile '{prof}'. Available: {', '.join(profiles)}"
-        blueprint._session_model_profile = prof
-        return f"Session default LLM profile set to '{prof}'"
-    # Override specific agent
-    if len(parts) == 2:
-        agent_name, prof = parts
-        if prof not in profiles:
-            return f"Unknown profile '{prof}'. Available: {', '.join(profiles)}"
-        blueprint._agent_model_overrides[agent_name] = prof
-        return f"Model for agent '{agent_name}' overridden to '{prof}'"
-    return "Usage: /model [agent_name] <profile_name>"
-
-# Built-in '/approval' slash command
-@slash_registry.register('/approval')
-def _approval_command(blueprint=None, args=None):
-    """Toggle or display auto-approval mode."""
-    return "[slash command] approval mode not implemented yet."
-
-# Built-in '/history' slash command
-@slash_registry.register('/history')
-def _history_command(blueprint=None, args=None):
-    """Display session history of commands and files."""
-    return "[slash command] history not implemented yet."
-
-# Built-in '/clear' slash command
-@slash_registry.register('/clear')
-def _clear_command(blueprint=None, args=None):
-    """Clear the screen and current context."""
-    return "[slash command] context cleared."
-
-# Built-in '/clearhistory' slash command
-@slash_registry.register('/clearhistory')
-def _clearhistory_command(blueprint=None, args=None):
-    """Clear the command history."""
-    return "[slash command] command history cleared."

swarm/core/swarm_api.py

@@ -1,68 +0,0 @@
-#!/usr/bin/env python3
-import argparse
-import subprocess
-import sys
-from os import path, listdir, makedirs
-
-def main():
-    parser = argparse.ArgumentParser(description="Swarm REST Launcher")
-    parser.add_argument("--blueprint", required=True, help="Comma-separated blueprint file paths or names for configuration purposes")
-    parser.add_argument("--port", type=int, default=8000, help="Port to run the REST server")
-    parser.add_argument("--config", default="~/.swarm/swarm_config.json", help="Configuration file path")
-    parser.add_argument("--daemon", action="store_true", help="Run in daemon mode and print process id")
-    args = parser.parse_args()
-
-    # Split blueprints by comma and strip whitespace
-    bp_list = [bp.strip() for bp in args.blueprint.split(",") if bp.strip()]
-    blueprint_paths = []
-    for bp_arg in bp_list:
-        resolved = None
-        if path.exists(bp_arg):
-            if path.isdir(bp_arg):
-                resolved = bp_arg
-                print(f"Using blueprint directory: {resolved}")
-            else:
-                resolved = bp_arg
-                print(f"Using blueprint file: {resolved}")
-        else:
-            managed_path = path.expanduser("~/.swarm/blueprints/" + bp_arg)
-            if path.isdir(managed_path):
-                matches = [f for f in listdir(managed_path) if f.startswith("blueprint_") and f.endswith(".py")]
-                if not matches:
-                    print("Error: No blueprint file found in managed directory:", managed_path)
-                    sys.exit(1)
-                resolved = path.join(managed_path, matches[0])
-                print(f"Using managed blueprint: {resolved}")
-            else:
-                print("Warning: Blueprint not found:", bp_arg, "- skipping.")
-                continue
-        if resolved:
-            blueprint_paths.append(resolved)
-
-    if not blueprint_paths:
-        print("Error: No valid blueprints found.")
-        sys.exit(1)
-    print("Blueprints to be configured:")
-    for bp in blueprint_paths:
-        print(" -", bp)
-
-    config_path = path.expanduser(args.config)
-    if not path.exists(config_path):
-        makedirs(path.dirname(config_path), exist_ok=True)
-        with open(config_path, 'w') as f:
-            f.write("{}")
-        print("Default config file created at:", config_path)
-
-    print("Launching Django server on port 0.0.0.0:{}".format(args.port))
-    try:
-        if args.daemon:
-            proc = subprocess.Popen(["python", "manage.py", "runserver", f"0.0.0.0:{args.port}"])
-            print("Running in daemon mode. Process ID:", proc.pid)
-        else:
-            subprocess.run(["python", "manage.py", "runserver", f"0.0.0.0:{args.port}"], check=True)
-    except subprocess.CalledProcessError as e:
-        print("Error launching Django server:", e)
-        sys.exit(1)
-
-if __name__ == "__main__":
-    main()

swarm/core/swarm_cli.py

@@ -1,216 +0,0 @@
-import os
-import typer
-import platformdirs
-import subprocess
-import sys
-from pathlib import Path
-import importlib.resources as pkg_resources
-import swarm # Import the main package to access its resources
-
-# --- Configuration ---
-APP_NAME = "swarm"
-APP_AUTHOR = "swarm-authors" # Replace if needed
-
-# Use platformdirs for user-specific data, config locations
-USER_DATA_DIR = Path(os.getenv("SWARM_USER_DATA_DIR", platformdirs.user_data_dir(APP_NAME, APP_AUTHOR)))
-USER_CONFIG_DIR = Path(os.getenv("SWARM_USER_CONFIG_DIR", platformdirs.user_config_dir(APP_NAME, APP_AUTHOR)))
-
-# *** CORRECTED: Define user bin dir as a subdir of user data dir ***
-USER_BIN_DIR = Path(os.getenv("SWARM_USER_BIN_DIR", USER_DATA_DIR / "bin"))
-
-# Derived paths
-BLUEPRINTS_DIR = USER_DATA_DIR / "blueprints"
-INSTALLED_BIN_DIR = USER_BIN_DIR # Keep using this variable name for clarity
-
-# Ensure directories exist
-BLUEPRINTS_DIR.mkdir(parents=True, exist_ok=True)
-INSTALLED_BIN_DIR.mkdir(parents=True, exist_ok=True) # Ensure the user bin dir is created
-USER_CONFIG_DIR.mkdir(parents=True, exist_ok=True)
-
-
-# --- Typer App ---
-app = typer.Typer(
-    help="Swarm CLI tool for managing blueprints.",
-    add_completion=True # Enable shell completion commands
-)
-
-# --- Helper Functions ---
-def find_entry_point(blueprint_dir: Path) -> str | None:
-    """Placeholder: Finds the main Python script in a blueprint directory."""
-    # Improve this logic: Look for a specific file, check pyproject.toml, etc.
-    for item in blueprint_dir.glob("*.py"):
-        if item.is_file() and not item.name.startswith("_"):
-            return item.name
-    return None
-
-# --- CLI Commands ---
-
-@app.command()
-def install(
-    blueprint_name: str = typer.Argument(..., help="Name of the blueprint directory to install."),
-    # Add options for specifying source dir if needed later
-):
-    """
-    Install a blueprint by creating a standalone executable using PyInstaller.
-    """
-    # Decide where to look for the source blueprint: User dir first, then bundled?
-    # For now, let's assume it must exist in the user dir for installation
-    # TODO: Enhance this to allow installing bundled blueprints directly?
-    source_dir = BLUEPRINTS_DIR / blueprint_name
-    if not source_dir.is_dir():
-        # Could also check bundled blueprints here if desired
-        typer.echo(f"Error: Blueprint source directory not found in user directory: {source_dir}", err=True)
-        typer.echo("Currently, only blueprints placed in the user directory can be installed.", err=True)
-        raise typer.Exit(code=1)
-
-    entry_point = find_entry_point(source_dir)
-    if not entry_point:
-        typer.echo(f"Error: Could not find entry point script in {source_dir}", err=True)
-        raise typer.Exit(code=1)
-
-    entry_point_path = source_dir / entry_point
-    output_bin = INSTALLED_BIN_DIR / blueprint_name
-    dist_path = USER_DATA_DIR / "dist" # PyInstaller dist path within user data
-    build_path = USER_DATA_DIR / "build" # PyInstaller build path within user data
-
-    typer.echo(f"Installing blueprint '{blueprint_name}'...")
-    typer.echo(f"  Source: {source_dir}")
-    typer.echo(f"  Entry Point: {entry_point}")
-    typer.echo(f"  Output Executable: {output_bin}")
-
-    pyinstaller_cmd = [
-        "pyinstaller",
-        "--onefile", # Create a single executable file
-        "--name", str(output_bin.name), # Name of the output executable
-        "--distpath", str(INSTALLED_BIN_DIR), # Output directory for the executable
-        "--workpath", str(build_path), # Directory for temporary build files
-        "--specpath", str(USER_DATA_DIR), # Directory for the .spec file
-        str(entry_point_path), # The main script to bundle
-    ]
-
-    typer.echo(f"Running PyInstaller: {' '.join(map(str, pyinstaller_cmd))}") # Use map(str,...) for Path objects
-
-    try:
-        # Use subprocess.run for better control and error handling
-        result = subprocess.run(pyinstaller_cmd, check=True, capture_output=True, text=True)
-        typer.echo("PyInstaller output:")
-        typer.echo(result.stdout)
-        typer.echo(f"Successfully installed '{blueprint_name}' to {output_bin}")
-    except FileNotFoundError:
-        typer.echo("Error: PyInstaller command not found. Is PyInstaller installed?", err=True)
-        raise typer.Exit(code=1)
-    except subprocess.CalledProcessError as e:
-        typer.echo(f"Error during PyInstaller execution (Return Code: {e.returncode}):", err=True)
-        typer.echo(e.stderr, err=True)
-        typer.echo("Check the output above for details.", err=True)
-        raise typer.Exit(code=1)
-    except Exception as e:
-        typer.echo(f"An unexpected error occurred: {e}", err=True)
-        raise typer.Exit(code=1)
-
-
-@app.command()
-def launch(blueprint_name: str = typer.Argument(..., help="Name of the installed blueprint executable to launch.")):
-    """
-    Launch a previously installed blueprint executable.
-    """
-    executable_path = INSTALLED_BIN_DIR / blueprint_name
-    if not executable_path.is_file() or not os.access(executable_path, os.X_OK):
-        typer.echo(f"Error: Blueprint executable not found or not executable: {executable_path}", err=True)
-        raise typer.Exit(code=1)
-
-    typer.echo(f"Launching '{blueprint_name}' from {executable_path}...")
-    try:
-        # Execute the blueprint directly
-        # Using subprocess.run is generally safer and more flexible than os.execv
-        result = subprocess.run([str(executable_path)], capture_output=True, text=True, check=False) # check=False to handle non-zero exits gracefully
-        typer.echo(f"--- {blueprint_name} Output ---")
-        typer.echo(result.stdout)
-        if result.stderr:
-            typer.echo("--- Errors/Warnings ---", err=True)
-            typer.echo(result.stderr, err=True)
-        typer.echo(f"--- '{blueprint_name}' finished (Return Code: {result.returncode}) ---")
-
-    except Exception as e:
-        typer.echo(f"Error launching blueprint: {e}", err=True)
-        raise typer.Exit(code=1)
-
-
-@app.command(name="list")
-def list_blueprints(
-    installed: bool = typer.Option(False, "--installed", "-i", help="List only installed blueprint executables."),
-    available: bool = typer.Option(False, "--available", "-a", help="List only available blueprints (source dirs).")
-):
-    """
-    Lists available blueprints (bundled and user-provided) and/or installed executables.
-    """
-    list_installed = not available or installed
-    list_available = not installed or available
-
-    # --- List Installed Blueprints ---
-    if list_installed:
-        typer.echo(f"--- Installed Blueprints (in {INSTALLED_BIN_DIR}) ---")
-        found_installed = False
-        if INSTALLED_BIN_DIR.exists():
-            try:
-                for item in INSTALLED_BIN_DIR.iterdir():
-                    # Basic check: is it a file and executable? Refine as needed.
-                    if item.is_file() and os.access(item, os.X_OK):
-                        typer.echo(f"- {item.name}")
-                        found_installed = True
-            except OSError as e:
-                typer.echo(f"(Warning: Could not read installed directory: {e})", err=True)
-        if not found_installed:
-            typer.echo("(No installed blueprint executables found)")
-        typer.echo("") # Add spacing
-
-    # --- List Available Blueprints (Bundled and User) ---
-    if list_available:
-        # --- Bundled ---
-        typer.echo("--- Bundled Blueprints (installed with package) ---")
-        bundled_found = False
-        try:
-            # Use importlib.resources to access the 'blueprints' directory within the installed 'swarm' package
-            bundled_blueprints_path = pkg_resources.files(swarm) / 'blueprints'
-
-            if bundled_blueprints_path.is_dir(): # Check if the directory exists in the package
-                for item in bundled_blueprints_path.iterdir():
-                    # Check if it's a directory containing an entry point (adapt check as needed)
-                    if item.is_dir() and not item.name.startswith("__"): # Skip __pycache__ etc.
-                        entry_point = find_entry_point(item) # Use helper, might need refinement
-                        if entry_point:
-                            typer.echo(f"- {item.name} (entry: {entry_point})")
-                            bundled_found = True
-        except ModuleNotFoundError:
-             typer.echo("(Could not find bundled blueprints - package structure issue?)", err=True)
-        except FileNotFoundError: # Can happen if package data wasn't included correctly
-             typer.echo("(Could not find bundled blueprints path - package data missing?)", err=True)
-        except Exception as e:
-            typer.echo(f"(Error accessing bundled blueprints: {e})", err=True)
-
-        if not bundled_found:
-            typer.echo("(No bundled blueprints found or accessible)")
-        typer.echo("") # Add spacing
-
-        # --- User ---
-        typer.echo(f"--- User Blueprints (in {BLUEPRINTS_DIR}) ---")
-        user_found = False
-        if BLUEPRINTS_DIR.exists() and BLUEPRINTS_DIR.is_dir():
-            try:
-                for item in BLUEPRINTS_DIR.iterdir():
-                    if item.is_dir():
-                        entry_point = find_entry_point(item) # Use helper
-                        if entry_point:
-                            typer.echo(f"- {item.name} (entry: {entry_point})")
-                            user_found = True
-            except OSError as e:
-                typer.echo(f"(Warning: Could not read user blueprints directory: {e})", err=True)
-
-        if not user_found:
-            typer.echo("(No user blueprints found)")
-        typer.echo("") # Add spacing
-
-
-# --- Main Execution Guard ---
-if __name__ == "__main__":
-    app()