open-swarm 0.1.1745126154__tar.gz → 0.1.1745126446__tar.gz

{open_swarm-0.1.1745126154 → open_swarm-0.1.1745126446}/.gitignore

@@ -31,7 +31,7 @@ MANIFEST
 #  Usually these files are written by a python script from a template
 #  before PyInstaller builds the exe, so as to inject date/other infos into it.
 *.manifest
-*.spec
+#*.spec
 
 # Installer logs
 pip-log.txt
@@ -197,3 +197,7 @@ openai-agents-python/*
 docker-compose.override.yml
 
 bin/*
+
+swarm_log.json
+swarm_log.json.lock
+test_db.sqlite3

{open_swarm-0.1.1745126154 → open_swarm-0.1.1745126446}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: open-swarm
-Version: 0.1.1745126154
+Version: 0.1.1745126446
 Summary: Open Swarm: Orchestrating AI Agent Swarms with Django
 Project-URL: Homepage, https://github.com/yourusername/open-swarm
 Project-URL: Documentation, https://github.com/yourusername/open-swarm/blob/main/README.md
@@ -45,6 +45,7 @@ Requires-Dist: jmespath>=1.0.1
 Requires-Dist: openai-agents>=0.0.1
 Requires-Dist: openai<2.0.0,>=1.3.0
 Requires-Dist: platformdirs>=4.0.0
+Requires-Dist: psutil>=7.0.0
 Requires-Dist: psycopg2-binary>=2.9.0
 Requires-Dist: pyinstaller>=5.13.0
 Requires-Dist: python-dotenv>=1.0.0

{open_swarm-0.1.1745126154 → open_swarm-0.1.1745126446}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "open-swarm"
-version = "0.1.1745126154"
+version = "0.1.1745126446"
 description = "Open Swarm: Orchestrating AI Agent Swarms with Django"
 readme = "README.md"
 requires-python = ">=3.10"
@@ -60,6 +60,7 @@ dependencies = [
     "drf-spectacular>=0.28.0",
     "jmespath>=1.0.1",
     "filelock>=3.18.0",
+    "psutil>=7.0.0",
 ]
 
 [project.urls]
@@ -72,6 +73,7 @@ Changelog = "https://github.com/yourusername/open-swarm/blob/main/CHANGELOG.md"
 swarm-api = "swarm.extensions.launchers.swarm_api:main"
 swarm-cli = "swarm.extensions.launchers.swarm_cli:app"
 codey = "swarm.blueprints.codey.blueprint_codey:main"
+poets = "swarm.blueprints.poets.blueprint_poets:main"
 
 [project.optional-dependencies]
 dev = [
@@ -163,3 +165,22 @@ omit = ["*/migrations/*", "*/tests/*", "src/swarm/settings.py", "src/swarm/wsgi.
 [tool.coverage.report]
 show_missing = true
 fail_under = 70
+
+[tool.uv]
+default-groups = ["dev"]
+
+[dependency-groups]
+dev = [
+    "factory-boy>=3.3.3",
+    "ipdb>=0.13.13",
+    "ipython>=8.34.0",
+    "mypy>=1.15.0",
+    "pre-commit>=4.2.0",
+    "pytest>=8.3.4",
+    "pytest-asyncio>=0.26.0",
+    "pytest-cov>=6.0.0",
+    "pytest-django>=4.10.0",
+    "pytest-mock>=3.14.0",
+    "ruff>=0.11.2",
+    "uv>=0.6.10",
+]

{open_swarm-0.1.1745126154 → open_swarm-0.1.1745126446}/src/swarm/blueprints/README.md

@@ -6,24 +6,25 @@ This directory contains example blueprints for the Open Swarm framework, showcas
 
 These blueprints have been updated to use the `BlueprintBase` class, `openai-agents` library conventions (like `Agent`, `@function_tool`, agent-as-tool delegation), and standardized configuration loading.
 
-| Blueprint Name                  | CLI (`uv run ...`) Example Instruction                | What it Demonstrates                                                           | Key Features                                                              | MCP Servers Used (Examples) |
-|---------------------------------|-------------------------------------------------------|--------------------------------------------------------------------------------|---------------------------------------------------------------------------|-----------------------------|
-| **EchoCraft**                   | `--instruction "Repeat this message"`                 | Simplest blueprint, direct input echo                                          | Basic `BlueprintBase` structure, Agent `process` override                 | None                        |
-| **Suggestion**                  | `--instruction "Topic: AI Ethics"`                    | Generating structured JSON output                                              | Agent `output_type=TypedDict`, JSON mode                                  | None                        |
-| **Chatbot**                     | `--instruction "Tell me a joke"`                      | Basic single-agent conversation                                                | Standard `Agent` interaction with LLM                                     | None                        |
-| **BurntNoodles**                | `--instruction "Check git status"`                    | Coordinating Git & testing tasks via function tools & agent delegation       | `@function_tool` for CLI commands, Agent-as-tool delegation             | None                        |
-| **RueCode**                     | `--instruction "Refactor this python code..."`        | Multi-agent code generation/refactoring workflow                             | Agent-as-tool delegation, specialized agent roles (Coordinator, Code, etc.) | memory                      |
-| **NebulaShellzzar**             | `--instruction "List files in /tmp"`                  | Matrix-themed sysadmin/coding tasks with delegation                        | Agent-as-tool delegation, `@function_tool` for shell/code analysis    | memory                      |
-| **DigitalButlers**              | `--instruction "Search for nearby restaurants"`       | Delegating tasks requiring specific MCPs (search, home automation)         | Agent-as-tool delegation, MCP usage by specialist agents                  | duckduckgo-search, home-assistant |
-| **DilbotUniverse (SQLite)**     | `--instruction "Start the SDLC"`                      | Comedic SDLC simulation, instructions loaded from SQLite                     | Agent-as-tool delegation, SQLite integration for dynamic prompts          | sqlite                      |
-| **FamilyTies**                  | `--instruction "Create WP post titled 'Hello'..."`    | Coordinating WordPress operations via MCP                                    | Agent-as-tool delegation, specialized agent using specific MCP (WP)     | server-wp-mcp               |
-| **MissionImprobable (SQLite)**  | `--instruction "Use RollinFumble to run 'pwd'"`       | Spy-themed ops, instructions from SQLite, multi-level delegation             | Agent-as-tool delegation, SQLite integration, MCP usage (fs, shell, mem)  | memory, filesystem, mcp-shell |
-| **WhiskeyTangoFoxtrot**       | `--instruction "Find free vector DBs"`                  | Hierarchical agents tracking services using DB & web search                | Multi-level agent delegation, SQLite, various search/scrape/doc MCPs    | sqlite, brave-search, mcp-npx-fetch, mcp-doc-forge, filesystem |
-| **DivineOps**                   | `--instruction "Design user auth API"`                | Large-scale SW dev coordination (Design, Implement, DB, DevOps, Docs)      | Complex delegation, wide range of MCP usage (search, shell, db, fs...)  | memory, filesystem, mcp-shell, sqlite, sequential-thinking, brave-search |
-| **Gaggle**                      | `--instruction "Write story: cat library"`            | Collaborative story writing (Planner, Writer, Editor)                        | Agent-as-tool delegation, function tools for writing steps                | None                        |
-| **MonkaiMagic**                 | `--instruction "List AWS S3 buckets"`                 | Cloud operations (AWS, Fly, Vercel) via direct CLI function tools          | `@function_tool` for external CLIs, agent-as-tool delegation            | mcp-shell (for Sandy)       |
-| **UnapologeticPress (SQLite)** | `--instruction "Write poem: city rain"`               | Collaborative poetry writing by distinct "poet" agents, SQLite instructions | Agent-as-tool (all-to-all), SQLite, broad MCP usage                       | Various (see blueprint)     |
-| **Omniplex**                    | `--instruction "Use filesystem to read README.md"`    | Dynamically routes tasks based on MCP server type (npx, uvx, other)      | Dynamic agent/tool creation based on available MCPs                     | Dynamic (all available)     |
+| Blueprint Name                  | CLI (`uv run ...`) Example Instruction                | What it Demonstrates                                                           | Key Features                                                              | Tags                  | MCP Servers Used (Examples) |
+|---------------------------------|-------------------------------------------------------|--------------------------------------------------------------------------------|---------------------------------------------------------------------------|-----------------------|-----------------------------|
+| **EchoCraft**                   | `--instruction "Repeat this message"`                 | Simplest blueprint, direct input echo                                          | Basic `BlueprintBase` structure, Agent `process` override                 |                       | None                        |
+| **Suggestion**                  | `--instruction "Topic: AI Ethics"`                    | Generating structured JSON output                                              | Agent `output_type=TypedDict`, JSON mode                                  |                       | None                        |
+| **Chatbot**                     | `--instruction "Tell me a joke"`                      | Basic single-agent conversation                                                | Standard `Agent` interaction with LLM                                     |                       | None                        |
+| **BurntNoodles**                | `--instruction "Check git status"`                    | Coordinating Git & testing tasks via function tools & agent delegation       | `@function_tool` for CLI commands, Agent-as-tool delegation             |                       | None                        |
+| **RueCode**                     | `--instruction "Refactor this python code..."`        | Multi-agent code generation/refactoring workflow                             | Agent-as-tool delegation, specialized agent roles (Coordinator, Code, etc.) | software-development  | memory                      |
+| **NebulaShellzzar**             | `--instruction "List files in /tmp"`                  | Matrix-themed sysadmin/coding tasks with delegation                        | Agent-as-tool delegation, `@function_tool` for shell/code analysis    |                       | memory                      |
+| **DigitalButlers**              | `--instruction "Search for nearby restaurants"`       | Delegating tasks requiring specific MCPs (search, home automation)         | Agent-as-tool delegation, MCP usage by specialist agents                  |                       | duckduckgo-search, home-assistant |
+| **DilbotUniverse (SQLite)**     | `--instruction "Start the SDLC"`                      | Comedic SDLC simulation, instructions loaded from SQLite                     | Agent-as-tool delegation, SQLite integration for dynamic prompts          |                       | sqlite                      |
+| **Stewie**                      | `--instruction "Create WP post titled 'Hello'..."`    | Coordinating WordPress operations via MCP                                    | Agent-as-tool delegation, specialized agent using specific MCP (WP)     |                       | server-wp-mcp               |
+| **MissionImprobable (SQLite)**  | `--instruction "Use RollinFumble to run 'pwd'"`       | Spy-themed ops, instructions from SQLite, multi-level delegation             | Agent-as-tool delegation, SQLite integration, MCP usage (fs, shell, mem)  |                       | memory, filesystem, mcp-shell |
+| **WhiskeyTangoFoxtrot**         | `--instruction "Find free vector DBs"`                | Hierarchical agents tracking services using DB & web search                | Multi-level agent delegation, SQLite, various search/scrape/doc MCPs    |                       | sqlite, brave-search, mcp-npx-fetch, mcp-doc-forge, filesystem |
+| **Zeus**                        | `--instruction "Design user auth API"`                | Replacement for DivineOps/DivineCode/DivineAss, large-scale SW dev coordination (Design, Implement, DB, DevOps, Docs)      | Complex delegation, wide range of MCP usage (search, shell, db, fs...)  | software-development  | memory, filesystem, mcp-shell, sqlite, sequential-thinking, brave-search |
+| **WhingeSurf**                  | `--instruction "Analyze blueprint code"`              | Self-analyzing/auto-improving blueprint, meta-agent demo                   | Code analysis, self-improvement, UX/ANSI output, meta-agent logic        | software-development  | None                        |
+| **Gaggle**                      | `--instruction "Write story: cat library"`            | Collaborative story writing (Planner, Writer, Editor)                        | Agent-as-tool delegation, function tools for writing steps                |                       | None                        |
+| **MonkaiMagic**                 | `--instruction "List AWS S3 buckets"`                 | Cloud operations (AWS, Fly, Vercel) via direct CLI function tools          | `@function_tool` for external CLIs, agent-as-tool delegation            |                       | mcp-shell (for Sandy)       |
+| **UnapologeticPress (SQLite)**  | `--instruction "Write poem: city rain"`               | Collaborative poetry writing by distinct "poet" agents, SQLite instructions | Agent-as-tool (all-to-all), SQLite, broad MCP usage                       |                       | Various (see blueprint)     |
+| **Omniplex**                    | `--instruction "Use filesystem to read README.md"`    | Dynamically routes tasks based on MCP server type (npx, uvx, other)      | Dynamic agent/tool creation based on available MCPs                     |                       | Dynamic (all available)     |
 
 ## WIP / Needs Refactoring
 

{open_swarm-0.1.1745126154 → open_swarm-0.1.1745126446}/src/swarm/blueprints/blueprint_audit_status.json

@@ -11,7 +11,6 @@
     {"name": "dilbot", "status": "unknown", "notes": "Needs audit"},
     {"name": "divine_code", "status": "unknown", "notes": "Needs audit"},
     {"name": "django_chat", "status": "unknown", "notes": "Needs audit"},
-    {"name": "family_ties", "status": "unknown", "notes": "Needs audit"},
     {"name": "flock", "status": "unknown", "notes": "Needs audit"},
     {"name": "gaggle", "status": "unknown", "notes": "Needs audit"},
     {"name": "gatcha", "status": "unknown", "notes": "Needs audit"},
@@ -21,6 +20,7 @@
     {"name": "nebula_shellz", "status": "unknown", "notes": "Needs audit"},
     {"name": "omniplex", "status": "unknown", "notes": "Needs audit"},
     {"name": "shell_demo", "status": "unknown", "notes": "Needs audit"},
+    {"name": "stewie", "status": "unknown", "notes": "Needs audit"},
     {"name": "unapologetic_press", "status": "unknown", "notes": "Needs audit"},
     {"name": "whiskeytango_foxtrot", "status": "unknown", "notes": "Needs audit"}
   ]

{open_swarm-0.1.1745126154 → open_swarm-0.1.1745126446}/src/swarm/blueprints/chatbot/blueprint_chatbot.py

@@ -7,18 +7,6 @@ import sys
 from typing import Dict, Any, List, ClassVar, Optional
 import argparse
 
-# Set logging to WARNING by default unless SWARM_DEBUG=1
-if not os.environ.get("SWARM_DEBUG"):
-    logging.basicConfig(level=logging.WARNING)
-else:
-    logging.basicConfig(level=logging.DEBUG)
-
-# Set logging to WARNING by default unless SWARM_DEBUG=1
-if not os.environ.get("SWARM_DEBUG"):
-    logging.basicConfig(level=logging.WARNING)
-else:
-    logging.basicConfig(level=logging.DEBUG)
-
 # Set logging to WARNING by default unless SWARM_DEBUG=1
 if not os.environ.get("SWARM_DEBUG"):
     logging.basicConfig(level=logging.WARNING)
@@ -30,40 +18,22 @@ project_root = os.path.abspath(os.path.join(os.path.dirname(__file__), '..', '..
 src_path = os.path.join(project_root, 'src')
 if src_path not in sys.path: sys.path.insert(0, src_path)
 
-from typing import Optional
-from pathlib import Path
-try:
-    # Patch: If MCPServer import fails, define a dummy MCPServer for demo/test
-    try:
-        from agents import Agent, MCPServer, function_tool
-        # Patch: Expose underlying fileops functions for direct testing
-        class PatchedFunctionTool:
-            def __init__(self, func, name):
-                self.func = func
-                self.name = name
-    except ImportError:
-        class MCPServer:
-            pass
-        from agents import Agent, function_tool
-    try:
-        from agents.mcp import MCPServer as MCPServer2
-    except ImportError:
-        MCPServer2 = MCPServer
-    from agents.models.interface import Model
-    from agents.models.openai_chatcompletions import OpenAIChatCompletionsModel
-    from openai import AsyncOpenAI
-    from swarm.core.blueprint_base import BlueprintBase
-except ImportError as e:
-    print(f"ERROR: Import failed in ChatbotBlueprint: {e}. Check dependencies.")
-    print(f"sys.path: {sys.path}")
-    sys.exit(1)
+from agents import Agent, function_tool
+from agents.mcp import MCPServer
+from agents.models.interface import Model
+from agents.models.openai_chatcompletions import OpenAIChatCompletionsModel
+from openai import AsyncOpenAI
+from swarm.core.blueprint_base import BlueprintBase
+from swarm.core.blueprint_ux import BlueprintUXImproved
+from agents import Runner
 
 logger = logging.getLogger(__name__)
 
 # --- Define the Blueprint ---
 class ChatbotBlueprint(BlueprintBase):
-    def __init__(self, blueprint_id: str, config_path: Optional[Path] = None, **kwargs):
-        super().__init__(blueprint_id, config_path=config_path, **kwargs)
+    def __init__(self, blueprint_id: str = "chatbot", config=None, config_path=None, **kwargs):
+        super().__init__(blueprint_id, config=config, config_path=config_path, **kwargs)
+        self.ux = BlueprintUXImproved(style="serious")
         class DummyLLM:
             def chat_completion_stream(self, messages, **_):
                 class DummyStream:
@@ -93,18 +63,15 @@ class ChatbotBlueprint(BlueprintBase):
     _openai_client_cache: Dict[str, AsyncOpenAI] = {}
     _model_instance_cache: Dict[str, Model] = {}
 
-    # Patch: Expose underlying fileops functions for direct testing
-    class PatchedFunctionTool:
-        def __init__(self, func, name):
-            self.func = func
-            self.name = name
-
+    @function_tool
     def read_file(path: str) -> str:
         try:
             with open(path, 'r') as f:
                 return f.read()
         except Exception as e:
             return f"ERROR: {e}"
+
+    @function_tool
     def write_file(path: str, content: str) -> str:
         try:
             with open(path, 'w') as f:
@@ -112,22 +79,37 @@ class ChatbotBlueprint(BlueprintBase):
             return "OK: file written"
         except Exception as e:
             return f"ERROR: {e}"
+
+    @function_tool
     def list_files(directory: str = '.') -> str:
         try:
             return '\n'.join(os.listdir(directory))
         except Exception as e:
             return f"ERROR: {e}"
+
+    @function_tool
     def execute_shell_command(command: str) -> str:
         import subprocess
+        import os
+        import logging
+        logger = logging.getLogger(__name__)
+        logger.info(f"Executing shell command: {command}")
         try:
-            result = subprocess.run(command, shell=True, capture_output=True, text=True)
-            return result.stdout + result.stderr
+            timeout = int(os.getenv("SWARM_COMMAND_TIMEOUT", "60"))
+            result = subprocess.run(command, shell=True, capture_output=True, text=True, timeout=timeout)
+            output = f"Exit Code: {result.returncode}\n"
+            if result.stdout:
+                output += f"STDOUT:\n{result.stdout}\n"
+            if result.stderr:
+                output += f"STDERR:\n{result.stderr}\n"
+            logger.info(f"Command finished. Exit Code: {result.returncode}")
+            return output.strip()
+        except subprocess.TimeoutExpired:
+            logger.error(f"Command timed out: {command}")
+            return f"Error: Command timed out after {os.getenv('SWARM_COMMAND_TIMEOUT', '60')} seconds."
         except Exception as e:
-            return f"ERROR: {e}"
-    read_file_tool = PatchedFunctionTool(read_file, 'read_file')
-    write_file_tool = PatchedFunctionTool(write_file, 'write_file')
-    list_files_tool = PatchedFunctionTool(list_files, 'list_files')
-    execute_shell_command_tool = PatchedFunctionTool(execute_shell_command, 'execute_shell_command')
+            logger.error(f"Error executing command '{command}': {e}", exc_info=True)
+            return f"Error executing command: {e}"
 
     # --- Model Instantiation Helper --- (Standard helper)
     def _get_model_instance(self, profile_name: str) -> Model:
@@ -179,34 +161,128 @@ You are a helpful and friendly chatbot. Respond directly to the user's input in
             name="Chatbot",
             model=model_instance,
             instructions=chatbot_instructions,
-            tools=[self.read_file_tool, self.write_file_tool, self.list_files_tool, self.execute_shell_command_tool],
+            tools=[self.read_file, self.write_file, self.list_files, self.execute_shell_command],
             mcp_servers=mcp_servers # Pass along, though likely unused
         )
 
         logger.debug("Chatbot agent created.")
         return chatbot_agent
 
-    async def run(self, messages: List[Dict[str, Any]], **kwargs) -> Any:
+    async def run(self, messages: List[Dict[str, Any]], **kwargs):
         """Main execution entry point for the Chatbot blueprint."""
         logger.info("ChatbotBlueprint run method called.")
         instruction = messages[-1].get("content", "") if messages else ""
-        async for chunk in self._run_non_interactive(instruction, **kwargs):
-            yield chunk
-        logger.info("ChatbotBlueprint run method finished.")
-
-    async def _run_non_interactive(self, instruction: str, **kwargs) -> Any:
-        mcp_servers = kwargs.get("mcp_servers", [])
-        agent = self.create_starting_agent(mcp_servers=mcp_servers)
         from agents import Runner
-        import os
-        model_name = os.getenv("LITELLM_MODEL") or os.getenv("DEFAULT_LLM") or "gpt-3.5-turbo"
+        spinner_idx = 0
+        start_time = time.time()
+        spinner_yield_interval = 1.0  # seconds
+        last_spinner_time = start_time
+        yielded_spinner = False
+        result_chunks = []
         try:
-            result = await Runner.run(agent, instruction)
-            yield {"messages": [{"role": "assistant", "content": getattr(result, 'final_output', str(result))}]}
+            runner_gen = Runner.run(self.create_starting_agent([]), instruction)
+            while True:
+                now = time.time()
+                try:
+                    chunk = next(runner_gen)
+                    result_chunks.append(chunk)
+                    # If chunk is a final result, wrap and yield
+                    if chunk and isinstance(chunk, dict) and "messages" in chunk:
+                        content = chunk["messages"][0]["content"] if chunk["messages"] else ""
+                        summary = self.ux.summary("Operation", len(result_chunks), {"instruction": instruction[:40]})
+                        box = self.ux.ansi_emoji_box(
+                            title="Chatbot Result",
+                            content=content,
+                            summary=summary,
+                            params={"instruction": instruction[:40]},
+                            result_count=len(result_chunks),
+                            op_type="run",
+                            status="success"
+                        )
+                        yield {"messages": [{"role": "assistant", "content": box}]}
+                    else:
+                        yield chunk
+                    yielded_spinner = False
+                except StopIteration:
+                    break
+                except Exception:
+                    if now - last_spinner_time >= spinner_yield_interval:
+                        taking_long = (now - start_time > 10)
+                        spinner_msg = self.ux.spinner(spinner_idx, taking_long=taking_long)
+                        yield {"messages": [{"role": "assistant", "content": spinner_msg}]}
+                        spinner_idx += 1
+                        last_spinner_time = now
+                        yielded_spinner = True
+            if not result_chunks and not yielded_spinner:
+                yield {"messages": [{"role": "assistant", "content": self.ux.spinner(0)}]}
         except Exception as e:
-            logger.error(f"Error during non-interactive run: {e}", exc_info=True)
+            logger.error(f"Error during Chatbot run: {e}", exc_info=True)
             yield {"messages": [{"role": "assistant", "content": f"An error occurred: {e}"}]}
 
+# --- Spinner and ANSI/emoji operation box for unified UX ---
+from swarm.ux.ansi_box import ansi_box
+from rich.console import Console
+from rich.style import Style
+from rich.text import Text
+import threading
+import time
+
+class ChatbotSpinner:
+    FRAMES = [
+        "Generating.", "Generating..", "Generating...", "Running...",
+        "⠋ Generating...", "⠙ Generating...", "⠹ Generating...", "⠸ Generating...",
+        "⠼ Generating...", "⠴ Generating...", "⠦ Generating...", "⠧ Generating...",
+        "⠇ Generating...", "⠏ Generating...", "🤖 Generating...", "💡 Generating...", "✨ Generating..."
+    ]
+    SLOW_FRAME = "⏳ Generating... Taking longer than expected"
+    INTERVAL = 0.12
+    SLOW_THRESHOLD = 10  # seconds
+
+    def __init__(self):
+        self._stop_event = threading.Event()
+        self._thread = None
+        self._start_time = None
+        self.console = Console()
+
+    def start(self):
+        self._stop_event.clear()
+        self._start_time = time.time()
+        self._thread = threading.Thread(target=self._spin, daemon=True)
+        self._thread.start()
+
+    def _spin(self):
+        idx = 0
+        while not self._stop_event.is_set():
+            elapsed = time.time() - self._start_time
+            if elapsed > self.SLOW_THRESHOLD:
+                txt = Text(self.SLOW_FRAME, style=Style(color="yellow", bold=True))
+            else:
+                frame = self.FRAMES[idx % len(self.FRAMES)]
+                txt = Text(frame, style=Style(color="cyan", bold=True))
+            self.console.print(txt, end="\r", soft_wrap=True, highlight=False)
+            time.sleep(self.INTERVAL)
+            idx += 1
+        self.console.print(" " * 40, end="\r")  # Clear line
+
+    def stop(self, final_message="Done!"):
+        self._stop_event.set()
+        if self._thread:
+            self._thread.join()
+        self.console.print(Text(final_message, style=Style(color="green", bold=True)))
+
+def print_operation_box(op_type, results, params=None, result_type="chat", taking_long=False):
+    emoji = "💬" if result_type == "chat" else "🔍"
+    style = 'success' if result_type == "chat" else 'default'
+    box_title = op_type if op_type else ("Chatbot Output" if result_type == "chat" else "Results")
+    summary_lines = []
+    count = len(results) if isinstance(results, list) else 0
+    summary_lines.append(f"Results: {count}")
+    if params:
+        for k, v in params.items():
+            summary_lines.append(f"{k.capitalize()}: {v}")
+    box_content = "\n".join(summary_lines + ["\n".join(map(str, results))])
+    ansi_box(box_title, box_content, count=count, params=params, style=style if not taking_long else 'warning', emoji=emoji)
+
 # Standard Python entry point
 if __name__ == "__main__":
     import sys
@@ -225,8 +301,20 @@ if __name__ == "__main__":
 
     blueprint = ChatbotBlueprint(blueprint_id="chatbot")
     async def runner():
-        async for chunk in blueprint._run_non_interactive(instruction):
-            msg = chunk["messages"][0]["content"]
-            if not msg.startswith("An error occurred:"):
-                print(msg)
+        spinner = ChatbotSpinner()
+        spinner.start()
+        try:
+            all_results = []
+            async for chunk in blueprint._run_non_interactive(instruction):
+                msg = chunk["messages"][0]["content"]
+                if not msg.startswith("An error occurred:"):
+                    all_results.append(msg)
+        finally:
+            spinner.stop()
+        print_operation_box(
+            op_type="Chatbot Output",
+            results=all_results,
+            params={"instruction": instruction},
+            result_type="chat"
+        )
     asyncio.run(runner())

open_swarm-0.1.1745126446/src/swarm/blueprints/codey/README.md

@@ -0,0 +1,143 @@
+# Codey Blueprint
+
+**Codey** is special because it presents advanced session management and code automation for developers using Open Swarm. It provides a seamless experience for managing code sessions, running code, and integrating with git and other developer tools.
+
+## Special Feature
+- **Session Management & Code Automation:** Manage your coding sessions, automate repetitive tasks, and streamline your workflow with Codey.
+
+Codey is an agentic coding assistant blueprint for Open Swarm, inspired by OpenAI Codex CLI. It orchestrates specialized agents and tools to automate and assist with software engineering tasks, especially those involving code, git, and project workflows.
+
+---
+
+## ✅ Features Implemented
+
+- **Global Instructions**: Reads and injects `~/.codey/instructions.md` as a base prompt for orchestration/coordinator agent.
+- **Agent Delegation**: Supports delegating tasks to specialized sub-agents (e.g., GitHub agent, code review agent).
+- **Tool Integration**: Git, file, and shell tools available to agents (e.g., git status, add, commit, push, file read/write).
+- **Dynamic Prompt Construction**: User requests, history, and tool descriptions included in LLM prompt.
+- **Basic ANSI/Emoji Output**: Some CLI output uses boxes/emojis for better UX.
+- **Rich Syntax Highlighting**: Code fences in assistant responses are colorized via Rich.
+- **Slash Commands**: Built-in `/help`, `/compact`, `/model`, `/approval`, `/history`, `/clear`, and `/clearhistory` available.
+- **Testable via CLI**: Supports test-driven development and CLI-based interaction.
+- **Project-Level Instructions**: Automatically loaded and injected from `CODEY.md` if present in the project. No manual step required.
+- **Interactive/Approval Mode**: Supports interactive prompts for git operations in suggest mode.
+- **Unified Rich Output Formatting**: Unified and enhanced rich output formatting (boxes, emojis, result summaries).
+- **Custom Spinner/Progress Messages**: Custom spinner/progress messages for better UX.
+- **Persistent Session Logging/Audit Trail**: Persistent log of actions, plans, or outputs.
+- **Full-Context Mode**: Full-context mode for large refactor/analysis.
+- **Writable Root/Sandboxing CLI/Config Support**: Writable root/sandboxing CLI/config support.
+- **Command Suggestions/Typeahead/Autocomplete**: Command suggestions/typeahead/autocomplete (CLI and slash commands).
+- **Session/History Management and Overlays**: Session/history management and overlays.
+- **Model Selection Overlay and CLI/Agent-Specific Support**: Model selection overlay and CLI/agent-specific support.
+- **Help and Onboarding Overlays**: Help and onboarding overlays.
+- **Desktop Notification Support**: Desktop notification support (optional).
+- **Dangerous Auto-Approve Flag/UX**: Dangerous auto-approve flag/UX.
+- **Output Formatting/Full Stdout Option**: Output formatting/full stdout option.
+- **Image Input**: Image input (CLI/UX, future-proof).
+
+---
+
+## ⚠️ Features Partially Implemented
+
+- **File/Directory Context Awareness**: File tools exist, but no automatic context file loading or project scanning.
+- **Rich Output Formatting**: Some ANSI/emoji UX, but not unified or as rich as Codex.
+- **User Feedback Loop**: No mechanism for user feedback/corrections mid-session.
+
+---
+
+## ❌ Features Not Yet Implemented
+
+- **Automatic Plan/Changelog Updates**: Agent does not maintain `.codey/plan_*.md` or changelogs automatically.
+- **Automatic Context Injection**: Agent does not scan/include relevant files automatically in prompts.
+
+---
+
+## Codex CLI Feature Parity Checklist
+
+This blueprint aims to match all core and advanced features of the OpenAI Codex CLI. Below is the current status:
+
+### ✅ Already Implemented
+- Rich output/emoji/spinner UX (unified for search, analysis, file ops)
+- Modular agent/blueprint system
+- Interactive CLI mode (basic)
+- Approval mode for git ops and some agent actions
+- Syntax-highlighted code output
+- Project-level instruction auto-loading (e.g., CODEY.md)
+- Slash commands: `/help`, `/compact`, `/model`, `/approval`, `/history`, `/clear`, `/clearhistory` (basic)
+- Persistent session logging/audit trail
+- Full-context mode for large refactor/analysis
+- Writable root/sandboxing CLI/config support
+- Command suggestions/typeahead/autocomplete (CLI and slash commands)
+- Session/history management and overlays
+- Model selection overlay and CLI/agent-specific support
+- Help and onboarding overlays
+- Desktop notification support (optional)
+- Dangerous auto-approve flag/UX
+- Output formatting/full stdout option
+- Image input (CLI/UX, future-proof)
+
+### ⚠️ Partially Implemented
+- Approval modes (full-auto, interactive, granular gating for all agent/file/code actions)
+- Directory sandboxing (not enforced everywhere, no network controls)
+- CLI/config file support (not unified or live-reloadable)
+- Version control integration (git ops for suggest mode only)
+
+### ❌ Not Yet Implemented
+- Auto dependency install for generated code
+- Automatic context/project file injection
+- Plan/changelog file maintenance
+- User feedback/correction loop
+- Streaming token-by-token CLI output
+- Non-interactive/CI/headless mode
+- Multimodal input (screenshots/diagrams)
+- Atomic commit/rollback for all agent actions
+- Safety/ZDR org restrictions
+
+---
+
+### Implementation Roadmap
+- [ ] Approval modes for all agent/file/code actions
+- [ ] Directory/network sandboxing for all agent execution
+- [ ] Auto dependency install for generated code
+- [ ] Automatic context injection for prompts
+- [ ] Plan/changelog file maintenance
+- [ ] User feedback/correction loop
+- [ ] Streaming CLI output
+- [ ] Non-interactive/CI/headless mode
+- [ ] Multimodal input support
+- [ ] Atomic commit/rollback for all agent actions
+- [ ] Safety/ZDR org restrictions
+
+---
+
+**See the root README for framework-wide feature status.**
+
+---
+
+## TODO
+
+- [x] Implement interactive/approval mode for agent actions
+- [x] Unify and enhance rich output formatting (boxes, emojis, result summaries)
+- [x] Add custom spinner/progress messages
+- [x] Enable automatic plan/changelog file updates
+- [x] Add project-level instruction auto-loading (e.g., `CODEY.md`)
+- [ ] Improve file/directory context awareness and context injection
+- [ ] Add user feedback/correction loop
+- [x] Add persistent session logging/audit trail
+- [ ] Implement summarization logic for `/compact` slash command
+- [ ] Implement model switching for `/model` slash command
+- [ ] Implement approval toggle for `/approval` slash command
+- [ ] Implement session history persistence for `/history` and `/clearhistory`
+- [ ] Enhance screen/context clearing for `/clear` slash command
+- [ ] Add interactive overlays for `/help`, `/model`, `/approval`, `/history`
+- [ ] Support external editor integration for prompts (e.g., `/edit` or Ctrl+E)
+- [ ] Add keyboard shortcut support (Ctrl+J newline, arrow history, Esc interrupt, Ctrl+C quit)
+- [ ] Enable streaming token-by-token responses in CLI
+- [ ] Expose `/explain` slash command for detailed shell command explanations
+- [ ] Add file-related slash commands (`/ls`, `/cat`, `/edit`)
+- [ ] Implement live config reload from `.env` or config file
+- [ ] Add suggestion/autocomplete for commands
+
+---
+
+Contributions and suggestions welcome! See `~/.codey/instructions.md` for global defaults, and update this TODO list as features are added.