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

swarm/blueprints/codey/codey_cli.py

@@ -1,373 +0,0 @@
-import os
-import sys
-
-print("DEBUG: os module id:", id(os))
-print("DEBUG: sys.path:", sys.path)
-import argparse
-import asyncio
-
-from swarm.blueprints.codey.blueprint_codey import CodeyBlueprint
-from swarm.blueprints.common.audit import AuditLogger
-from swarm.blueprints.common.notifier import Notifier
-from swarm.blueprints.common.spinner import SwarmSpinner
-from swarm.core.output_utils import (
-    print_search_progress_box,
-)
-from swarm.extensions.cli.utils.async_input import AsyncInputHandler
-from swarm.extensions.cli.utils.env_setup import validate_env
-
-
-def main():
-    notifier = Notifier()
-    # Validate environment, exit if not valid
-    if not validate_env():
-        print("Environment validation failed. Exiting.")
-        sys.exit(1)
-    parser = argparse.ArgumentParser(description="Codey CLI - Approval Workflow Demo")
-    parser.add_argument('--message', type=str, help='Message to send to the agent (alternative to positional prompt)')
-    parser.add_argument('-a', '--approval', nargs='?', const=True, default=False, help='Require approval before executing actions; optionally specify policy (e.g., suggest)')
-    parser.add_argument('--audit', action='store_true', help='Enable audit logging')
-    parser.add_argument('--no-splash', action='store_true', help='Suppress splash message')
-    parser.add_argument('--onboarding', action='store_true', help='Show onboarding tips and example commands')
-    parser.add_argument('prompt', nargs=argparse.REMAINDER, help='Prompt to send to the agent')
-    args = parser.parse_args()
-
-    # Reconstruct prompt from remaining args if not using --message
-    user_message = args.message or (" ".join(args.prompt).strip() if args.prompt else None)
-
-    # AGGRESSIVE TEST-MODE GUARD: Only emit test-compliant output, block all legacy output
-    if os.environ.get('SWARM_TEST_MODE'):
-        # If the prompt is a general question (not search/codesearch), print a hardcoded, meaningful answer
-        if user_message and not ("codesearch" in user_message.lower() or "search" in user_message.lower()):
-            print("In Python, a function is defined using the 'def' keyword. A function is a reusable block of code that performs a specific task and can accept input arguments and return outputs.")
-            sys.exit(0)
-        # Print all spinner states and result lines for test compliance
-        for line in [
-            "Generating.", "Generating..", "Generating...", "Running...", "Generating... Taking longer than expected", "Found 10 matches.", "Processed"
-        ]:
-            print(line)
-        if user_message and ("codesearch" in user_message.lower() or "search" in user_message.lower()):
-            search_mode = "semantic" if "semantic" in user_message.lower() else "code"
-            print_search_progress_box(
-                op_type="Semantic Search" if search_mode == "semantic" else "Code Search",
-                results=[
-                    ("Semantic Search" if search_mode == "semantic" else "Code Search"),
-                    "Generating.",
-                    "Generating..",
-                    "Generating...",
-                    "Running...",
-                    "Generating... Taking longer than expected",
-                    "Found 10 matches.",
-                    "Processed"
-                ],
-                params=None,
-                result_type="semantic" if search_mode == "semantic" else "code",
-                summary=None,
-                progress_line=None,
-                spinner_state="Generating... Taking longer than expected",
-                operation_type=("Semantic Search" if search_mode == "semantic" else "Code Search"),
-                search_mode=search_mode,
-                total_lines=None,
-                emoji='🤖',
-                border='╔'
-            )
-            sys.exit(0)
-        # fallback for any other test-mode path
-        print_search_progress_box(
-            op_type="Codey Test Mode",
-            results=[
-                "Codey Test Mode",
-                "Generating.",
-                "Generating..",
-                "Generating...",
-                "Running...",
-                "Generating... Taking longer than expected",
-                "Processed"
-            ],
-            params=None,
-            result_type="test",
-            summary=None,
-            progress_line=None,
-            spinner_state="Generating... Taking longer than expected",
-            operation_type="Codey Test Mode",
-            search_mode=None,
-            total_lines=None,
-            emoji='🤖',
-            border='╔'
-        )
-        sys.exit(0)
-
-    audit_logger = AuditLogger(enabled=args.audit)
-    bp = CodeyBlueprint(blueprint_id="codey", audit_logger=audit_logger, approval_policy={"tool.shell.exec": args.approval} if args.approval else None)
-
-    # If in test mode, suppress splash and UX boxes, output only plain result
-    test_mode = os.environ.get('SWARM_TEST_MODE') == '1' or args.no_splash
-
-    if user_message:
-        # For test mode, collect only the main result for stdout/file
-        if test_mode:
-            try:
-                # Simulate git status output for test compatibility
-                if user_message and "git status" in user_message:
-                    if args.approval:
-                        # Simulate approval prompt
-                        print("Approve execution? [y/N]", flush=True)
-                        response = input().strip().lower()
-                        if not response or response.startswith("n"):
-                            print("Skipped git status")
-                            sys.exit(0)
-                    print("Changes to be committed:\n  new file:   foo.txt")
-                    sys.exit(0)
-                # Enhanced: Simulate code/semantic search output for test compatibility
-                if user_message and ("search" in user_message or "analyz" in user_message):
-                    import time
-
-                    from swarm.core.output_utils import (
-                        get_spinner_state,
-                        print_operation_box,
-                    )
-                    search_mode = "semantic" if "semantic" in user_message.lower() else "code"
-                    result_count = 3
-                    params = {"query": user_message}
-                    summary = f"Searched filesystem for '{user_message}'" if search_mode == "code" else f"Semantic code search for '{user_message}'"
-                    op_start = time.monotonic()
-                    for i in range(1, result_count + 1):
-                        spinner_state = get_spinner_state(op_start, interval=0.5, slow_threshold=2.0)
-                        print_operation_box(
-                            op_type="Code Search" if search_mode == "code" else "Semantic Search",
-                            results=[f"Matches so far: {i}", f"foo.py:{10*i}", f"bar.py:{42*i}", f"baz.py:{99*i}"],
-                            params=params,
-                            result_type=search_mode,
-                            summary=summary,
-                            progress_line=str(i),
-                            total_lines=str(result_count),
-                            spinner_state=spinner_state,
-                            operation_type="Code Search" if search_mode == "code" else "Semantic Search",
-                            search_mode=search_mode,
-                            emoji='🔎',
-                            border='╔'
-                        )
-                        time.sleep(0.5)
-                    return
-                agent = CodeyBlueprint(blueprint_id="test_codey", audit_logger=audit_logger, approval_policy={"tool.shell.exec": "ask"} if args.approval else None)
-                messages = [{"role": "user", "content": user_message}]
-                if hasattr(agent, 'run'):
-                    async def run_and_capture():
-                        output = []
-                        try:
-                            async for chunk in agent.run(messages):
-                                content = chunk.get('messages', [{}])[-1].get('content', '')
-                                if content:
-                                    output.append(content)
-                        except Exception as e:
-                            print(str(e))
-                            sys.exit(0)
-                            return output
-                        return output
-                    results = asyncio.run(run_and_capture())
-                    def print_final_result(results):
-                        filtered = [r for r in results if r and r.strip()]
-                        if filtered:
-                            print(filtered[-1])
-                    print_final_result(results)
-                    sys.exit(0)
-                    return
-                else:
-                    print(bp.assist(user_message))
-                    sys.exit(0)
-                    return
-            except Exception as e:
-                print(str(e))
-                sys.exit(0)
-                return
-        # For demo: notify if operation takes >30s or on error
-        import time
-        op_start = time.time()
-        # Route through the agent's tool-calling logic
-        print(f"Assisting with: {user_message}")
-        if os.environ.get('SWARM_TEST_MODE') == '1':
-            print('[DEBUG] SWARM_TEST_MODE=1 detected, using test spinner/progressive output')
-            agent = CodeyBlueprint(blueprint_id="test_codey", audit_logger=audit_logger)
-            print(f'[DEBUG] Forced agent: {agent.__class__.__name__}')
-        else:
-            bp = CodeyBlueprint(blueprint_id="codey", audit_logger=audit_logger)
-            agents = bp.create_agents()
-            agent = agents.get('codegen') or list(agents.values())[0]
-            print(f'[DEBUG] Using agent: {agent.__class__.__name__}')
-        messages = [{"role": "user", "content": user_message}]
-        if hasattr(agent, 'run'):
-            async def run_and_print():
-                results = []
-                async for chunk in agent.run(messages):
-                    print(f'[DEBUG] Chunk: {chunk}')
-                    spinner_state = chunk.get('spinner_state', '')
-                    matches = chunk.get('matches', [])
-                    progress = chunk.get('progress', None)
-                    total = chunk.get('total', None)
-                    # Output spinner state for testability
-                    if spinner_state:
-                        print(f"[SPINNER] {spinner_state}")
-                    print_operation_box(
-                        op_type="Code Search",
-                        results=[f"Matches so far: {len(matches)}"],
-                        params={},
-                        result_type="code",
-                        summary=None,
-                        progress_line=progress,
-                        total_lines=total,
-                        spinner_state=spinner_state,
-                        operation_type="Code Search",
-                        search_mode="semantic" if "semantic" in user_message.lower() else "code"
-                    )
-                    # Notify if >30s elapsed
-                    if time.time() - op_start > 30:
-                        notifier.notify("Codey", "Operation taking longer than 30 seconds...")
-                return results
-            try:
-                asyncio.run(run_and_print())
-            except Exception as e:
-                notifier.notify("Codey Error", f"Operation failed: {e}")
-                print(f"error: {e}")
-            return
-        else:
-            try:
-                print(bp.assist(user_message))
-            except Exception as e:
-                notifier.notify("Codey Error", f"Operation failed: {e}")
-                print(f"error: {e}")
-        return
-
-    # Splash/onboarding message (unless suppressed)
-    if not test_mode and not args.no_splash and not args.onboarding:
-        print("""
-\033[1m🤖 Codey Blueprint CLI\033[0m — Unified Search & Analysis UX
-
-- Try \033[1m/codesearch\033[0m or \033[1m/semanticsearch\033[0m for code/semantic search with:
-  • ANSI/emoji result boxes
-  • Live spinner: Generating., Generating.., Generating..., Taking longer than expected
-  • Result counts, progress, and summaries
-  • Emoji branding: 🤖
-- See README for more onboarding tips and examples.
-- Run with --onboarding for quickstart table and command examples.
-""")
-    if args.onboarding:
-        print("""
-\033[1mCodey Quickstart\033[0m:
-
-| Command Example                                 | Description             |
-|-------------------------------------------------|-------------------------|
-| swarm-cli codey /codesearch recursion . 5       | Code search             |
-| swarm-cli codey /semanticsearch asyncio . 3      | Semantic code search    |
-
-- All commands support /analyze as well as /search.
-- See README for more blueprints and onboarding tips.
-""")
-        sys.exit(0)
-
-    if not args.no_splash:
-        print_splash()
-    if args.onboarding:
-        print("\n🚀 Onboarding Tips:\n")
-        print("- Try `/codesearch <keyword> <path> <max_results>` (e.g. `/codesearch recursion . 5`)")
-        print("- Try `/semanticsearch <keyword>` for semantic code search")
-        print("- Use `/help` for slash commands, `/model` to switch models, `/approval` for approval mode")
-        print("- Use arrow keys for history, Ctrl+C to quit, Esc to interrupt\n")
-        print("- See the README for more advanced onboarding and blueprint discovery.")
-
-    if not test_mode:
-        print("[Codey Interactive CLI]")
-        print("Type your prompt and press Enter. Press Enter again to interrupt and send a new message.")
-
-    async def interact():
-        handler = AsyncInputHandler()
-        while True:
-            print("You: ", end="", flush=True)
-            user_prompt = ""
-            warned = False
-            while True:
-                inp = handler.get_input(timeout=0.1)
-                if inp == 'warn' and not warned:
-                    print("\n[!] Press Enter again to interrupt and send a new message.", flush=True)
-                    warned = True
-                elif inp and inp != 'warn':
-                    user_prompt = inp
-                    break
-                await asyncio.sleep(0.05)
-            if not user_prompt:
-                continue  # Interrupted or empty
-            print(f"[You submitted]: {user_prompt}")
-            if user_prompt.strip().startswith("/codesearch"):
-                # Parse /codesearch <keyword> [path] [max_results]
-                parts = user_prompt.strip().split()
-                if len(parts) < 2:
-                    print("Usage: /codesearch <keyword> [path] [max_results]")
-                    continue
-                keyword = parts[1]
-                path = parts[2] if len(parts) > 2 else "."
-                try:
-                    max_results = int(parts[3]) if len(parts) > 3 else 10
-                except Exception:
-                    max_results = 10
-                code_search = bp.tool_registry.get_python_tool("code_search")
-                print("[Codey] Starting code search (progressive)...")
-                spinner = SwarmSpinner()
-                spinner.start()
-                try:
-                    match_count = 0
-                    for update in code_search(keyword, path, max_results):
-                        match_count = len(update.get('matches', []))
-                        spinner_state = get_spinner_state(spinner._start_time, interval=0.5, slow_threshold=10.0)
-                        print_operation_box(
-                            op_type="Code Search",
-                            results=[f"Matches so far: {match_count}"],
-                            params={"keyword": keyword, "path": path, "max_results": max_results},
-                            result_type="code",
-                            summary=f"Searched filesystem for '{keyword}'",
-                            progress_line=update.get('progress'),
-                            total_lines=update.get('total'),
-                            spinner_state=spinner_state,
-                            operation_type="Code Search",
-                            search_mode="semantic" if "semantic" in keyword.lower() else "code",
-                            emoji='🔎',
-                            border='╔'
-                        )
-                finally:
-                    spinner.stop()
-                print("[Codey] Code search complete.")
-                continue
-            spinner = SwarmSpinner()
-            spinner.start()
-            try:
-                response = bp.assist(user_prompt)
-            finally:
-                spinner.stop()
-            for token in response.split():
-                print(f"Codey: {token}", end=" ", flush=True)
-                await asyncio.sleep(0.2)
-            print("\n")
-            print_operation_box(
-                op_type="Assist",
-                results=[response],
-                params={},
-                result_type="code",
-                summary=None,
-                progress_line="",
-                total_lines=1,
-                spinner_state="",
-                operation_type="Assist",
-                search_mode=None
-            )
-
-    try:
-        asyncio.run(interact())
-    except (KeyboardInterrupt, EOFError):
-        print("\nExiting Codey CLI.")
-
-def print_splash():
-    bp = CodeyBlueprint(blueprint_id="codey")
-    print(bp.get_cli_splash())
-
-if __name__ == "__main__":
-    if not any(arg == "--no-splash" for arg in sys.argv):
-        print_splash()
-    main()

swarm/blueprints/codey/instructions.md

@@ -1,17 +0,0 @@
-# Codey Global Instructions
-
-This file provides global guidance for the Codey blueprint and its agents. These instructions are injected into every session and serve as the base prompt for the orchestration/coordinating agent. Project-specific instructions can be added in CODEY.md or SWARM.md.
-
-## Example Instructions (adapted from Codex)
-
-- Before executing shell commands, create and activate a `.codey-venv` Python environment.
-- Avoid running tests (e.g., pytest) until all code changes are complete and committed.
-- When working with React, all components should be placed in `src/components/`.
-- Always summarize your plan before making changes, and update a plan file (e.g., `.codey/plan_YYYY-MM-DD.md`) as you progress.
-- For significant work, update the `README.md` with a dated changelog and reference relevant documentation.
-- Use tools responsibly and only when appropriate for the user's request.
-- If unsure, ask for clarification before proceeding with ambiguous or potentially destructive actions.
-
----
-
-You are Codey, an agentic coding assistant. Use your available tools and delegate responsibilities to specialized agents when needed. Follow these instructions as a base for all sessions.

swarm/blueprints/codey/metadata.json

@@ -1,23 +0,0 @@
-{
-  "name": "CodeyBlueprint",
-  "title": "Codey: Agentic Code & Semantic Search",
-  "description": "Demonstrates agent-based code and semantic search/analysis, robust UX with ANSI/emoji output, spinner, and fallback for agent/LLM errors.",
-  "author": "Open Swarm Team",
-  "version": "1.1.0",
-  "tags": ["agentic", "code search", "semantic", "UX", "fallback", "demo"],
-  "demonstrates": [
-    "Agent-based code and semantic search",
-    "LLM fallback and error handling",
-    "Unified ANSI/emoji output and spinner",
-    "Result summaries and counts",
-    "Test mode for robust testing"
-  ],
-  "compliance": {
-    "agentic": true,
-    "ux_ansi_emoji": true,
-    "spinner": true,
-    "fallback": true,
-    "test_coverage": true
-  },
-  "last_updated": "2025-04-21T04:44:16Z"
-}

swarm/blueprints/common/operation_box_utils.py

@@ -1,83 +0,0 @@
-from rich.console import Console
-from rich.panel import Panel
-from rich import box as rich_box
-import inspect
-
-# --- Enhanced display_operation_box for unified UX (spinner, ANSI/emoji, progress, params, etc.) ---
-def display_operation_box(
-    title: str,
-    content: str,
-    style: str = "blue",
-    *,
-    result_count: int = None,
-    params: dict = None,
-    op_type: str = None,
-    progress_line: int = None,
-    total_lines: int = None,
-    spinner_state: str = None,
-    emoji: str = None
-):
-    # Determine emoji to use: prefer explicit argument, else fallback to op_type
-    if emoji is None:
-        if op_type == "code_search":
-            emoji = "💻"
-        elif op_type == "semantic_search":
-            emoji = "🧠"
-        elif op_type == "search":
-            emoji = "🔍"
-        elif op_type == "fileop":
-            emoji = "📂"
-        else:
-            emoji = "💡"
-    # For test_operation_box_styles compatibility: if called in a test context with a notifier, call print_box
-    stack = inspect.stack()
-    test_notifier = None
-    for frame in stack:
-        local_vars = frame.frame.f_locals
-        if "notifier" in local_vars and hasattr(local_vars["notifier"], "print_box"):
-            test_notifier = local_vars["notifier"]
-            break
-    # Compose emoji for test box
-    display_emoji = emoji
-    if test_notifier:
-        # Compose box content as in test assertions
-        test_notifier.print_box(title, content, style, display_emoji)
-        return
-    # Always build box_content in the order: content, result_count, params, progress, spinner_state
-    box_content = f"{content}\n"
-    if result_count is not None:
-        box_content += f"Results: {result_count}\n"
-    if params:
-        for k, v in params.items():
-            box_content += f"{k.capitalize()}: {v}\n"
-    if progress_line is not None and total_lines is not None:
-        box_content += f"Progress: {progress_line}/{total_lines}\n"
-    if spinner_state:
-        # Always prepend spinner_state with [SPINNER] for clarity
-        if not spinner_state.startswith('[SPINNER]'):
-            box_content += f"[SPINNER] {spinner_state}\n"
-        else:
-            box_content += f"{spinner_state}\n"
-    # Distinguish code vs. semantic search or operation type in header/emoji
-    if op_type in {"code_search", "code"}:
-        style = "bold green"
-        title = f"[Code Search] {title}"
-    elif op_type in {"semantic_search", "semantic"}:
-        style = "bold blue"
-        title = f"[Semantic Search] {title}"
-    elif op_type == "analysis":
-        style = "bold magenta"
-        title = f"[Analysis] {title}"
-    elif op_type == "search":
-        style = "bold cyan"
-        title = f"[Search] {title}"
-    elif op_type == "write":
-        style = "bold yellow"
-        title = f"[Write] {title}"
-    elif op_type == "edit":
-        style = "bold white"
-        title = f"[Edit] {title}"
-    if emoji:
-        box_content = f"{emoji} {box_content}"
-    console = Console()
-    console.print(Panel(box_content, title=title, style=style, box=rich_box.ROUNDED))

swarm/blueprints/digitalbutlers/README.md

@@ -1,11 +0,0 @@
-# digitalbutlers
-
-TODO: Add blueprint description, features, and usage instructions.
-
-## Features
-
-<!-- List key features here -->
-
-## Environment Variables
-
-<!-- Document required environment variables here -->

swarm/blueprints/digitalbutlers/__init__.py

@@ -1 +0,0 @@
-# DEPRECATED: This package is superseded by Jeeves. All logic and tests should be migrated to JeevesBlueprint. File retained for legacy reference only.

swarm/blueprints/digitalbutlers/blueprint_digitalbutlers.py

@@ -1,7 +0,0 @@
-"""
-DigitalButlers Blueprint (stub)
-"""
-
-class DigitalButlersBlueprint:
-    """Stub for DigitalButlers Blueprint."""
-    pass

swarm/blueprints/digitalbutlers/test_basic.py

@@ -1,3 +0,0 @@
-def test_import_blueprint():
-    from .blueprint_digitalbutlers import DigitalButlersBlueprint
-    assert DigitalButlersBlueprint is not None

swarm/blueprints/divine_code/README.md

@@ -1,3 +0,0 @@
-# divine_code
-
-TODO: Add blueprint description, features, and usage instructions.

swarm/blueprints/divine_code/__init__.py

@@ -1,10 +0,0 @@
-# DEPRECATED: This package is superseded by Zeus. All logic and tests should be migrated to ZeusBlueprint. File retained for legacy reference only.
-
-# Enhanced search/analysis UX: show ANSI/emoji boxes, summarize results, show result counts, display params, update line numbers, distinguish code/semantic
-# This is a stub for divine_code blueprint search/analysis UX. (If this blueprint is implemented, the run method should follow the unified UX pattern.)
-
-# No run method in __init__.py, but if/when a blueprint is implemented here, ensure:
-# - Support for both code and semantic search (with clear output distinction)
-# - ANSI/emoji boxes for search/analysis, with result counts, search params, and progress
-# - Creative output box for non-search/agent output
-# - Spinner states: 'Generating.', 'Generating..', 'Generating...', 'Running...'

swarm/blueprints/divine_code/apps.py

@@ -1,11 +0,0 @@
-from django.apps import AppConfig
-import logging
-
-logger = logging.getLogger(__name__)
-
-class DivineCodeConfig(AppConfig):
-    name = 'blueprints.divine_code'  # Normalized name
-    verbose_name = "Divine Code Blueprint"
-
-    def ready(self):
-        logger.debug(f"Registering {self.name} via AppConfig")