open-swarm 0.1.1745125933__py3-none-any.whl → 0.1.1745126277__py3-none-any.whl

swarm/blueprints/rue_code/blueprint_rue_code.py

@@ -15,6 +15,9 @@ import re
 from datetime import datetime
 import pytz
 from swarm.core.blueprint_ux import BlueprintUX
+from swarm.core.config_loader import load_full_configuration
+import time
+from swarm.blueprints.common.operation_box_utils import display_operation_box
 
 # Configure logging
 logging.basicConfig(level=logging.INFO, format='[%(levelname)s] %(asctime)s - %(name)s - %(message)s')
@@ -46,12 +49,37 @@ def list_files(directory: str = '.') -> str:
     except Exception as e:
         return f"ERROR: {e}"
 def execute_shell_command(command: str) -> str:
-    import subprocess
+    """
+    Executes a shell command and returns its stdout and stderr.
+    Security Note: Ensure commands are properly sanitized or restricted.
+    Timeout is configurable via SWARM_COMMAND_TIMEOUT (default: 60s).
+    """
+    logger.info(f"Executing shell command: {command}")
     try:
-        result = subprocess.run(command, shell=True, capture_output=True, text=True)
-        return result.stdout + result.stderr
+        import os
+        timeout = int(os.getenv("SWARM_COMMAND_TIMEOUT", "60"))
+        result = subprocess.run(
+            command,
+            shell=True,
+            check=False, # Don't raise exception on non-zero exit code
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            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}"
+        logger.error(f"Error executing command '{command}': {e}", exc_info=True)
+        return f"Error executing command: {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')
@@ -191,8 +219,42 @@ def execute_shell_command_fileops(command: str) -> str:
     except Exception as e:
         return f"ERROR: {e}"
 
-# --- RueCodeBlueprint Definition ---
+# --- LLM Cost Estimation Tool ---
+def calculate_llm_cost(model: str, prompt_tokens: int, completion_tokens: int = 0, config: dict = None) -> float:
+    """
+    Calculate the estimated cost (USD) for an LLM API call based on model and token usage.
+    Pricing is pulled from swarm_config.json if available, else defaults.
+    """
+    # Default prices (per 1K tokens)
+    default_price = {'prompt': 0.002, 'completion': 0.004}
+    price = None
+    model_key = model.lower()
+    if config:
+        llm_config = config.get('llm', {})
+        for key, val in llm_config.items():
+            m = val.get('model', '').lower()
+            if m == model_key or key.lower() == model_key:
+                # Support both single cost (same for prompt/completion) or dict
+                if isinstance(val.get('cost'), dict):
+                    price = val['cost']
+                elif 'cost' in val:
+                    price = {'prompt': float(val['cost']), 'completion': float(val['cost'])}
+                break
+    if price is None:
+        price = default_price
+    cost = (prompt_tokens / 1000.0) * price['prompt'] + (completion_tokens / 1000.0) * price['completion']
+    return round(cost, 6)
+
+def llm_cost_tool(model: str, prompt_tokens: int, completion_tokens: int = 0, config: dict = None) -> str:
+    try:
+        cost = calculate_llm_cost(model, prompt_tokens, completion_tokens, config)
+        return f"Estimated cost for {model}: ${cost} (prompt: {prompt_tokens}, completion: {completion_tokens} tokens)"
+    except Exception as e:
+        return f"Error: {e}"
 
+llm_cost_tool_fn = PatchedFunctionTool(llm_cost_tool, 'llm_cost')
+
+# --- RueCodeBlueprint Definition ---
 # === OpenAI GPT-4.1 Prompt Engineering Guide ===
 # See: https://github.com/openai/openai-cookbook/blob/main/examples/gpt4-1_prompting_guide.ipynb
 #
@@ -203,6 +265,31 @@ If you are not sure about file content or codebase structure pertaining to the u
 You MUST plan extensively before each function call, and reflect extensively on the outcomes of the previous function calls. DO NOT do this entire process by making function calls only, as this can impair your ability to solve the problem and think insightfully.
 """
 
+class RueSpinner:
+    FRAMES = ["Generating.", "Generating..", "Generating...", "Running..."]
+    LONG_WAIT_MSG = "Generating... Taking longer than expected"
+    INTERVAL = 0.12
+    SLOW_THRESHOLD = 10
+
+    def __init__(self):
+        self._idx = 0
+        self._start_time = None
+        self._last_frame = self.FRAMES[0]
+
+    def start(self):
+        self._start_time = time.time()
+        self._idx = 0
+        self._last_frame = self.FRAMES[0]
+
+    def _spin(self):
+        self._idx = (self._idx + 1) % len(self.FRAMES)
+        self._last_frame = self.FRAMES[self._idx]
+
+    def current_spinner_state(self):
+        if self._start_time and (time.time() - self._start_time) > self.SLOW_THRESHOLD:
+            return self.LONG_WAIT_MSG
+        return self._last_frame
+
 class RueCodeBlueprint(BlueprintBase):
     """
     A blueprint designed for code generation, execution, and file system interaction.
@@ -217,8 +304,23 @@ class RueCodeBlueprint(BlueprintBase):
         "llm_profile": "default_dev" # Example: Suggests a profile suitable for coding
     }
 
-    def __init__(self, *args, **kwargs):
-        super().__init__(*args, **kwargs)
+    def __init__(self, blueprint_id: str = "rue_code", config=None, config_path=None, **kwargs):
+        super().__init__(blueprint_id, config=config, config_path=config_path, **kwargs)
+        self.blueprint_id = blueprint_id
+        self.config_path = config_path
+        self._config = config if config is not None else None
+        self._llm_profile_name = None
+        self._llm_profile_data = None
+        self._markdown_output = None
+        # Use standardized config loader
+        if self._config is None:
+            self._config = load_full_configuration(
+                blueprint_class_name=self.__class__.__name__,
+                default_config_path=Path(os.path.dirname(__file__)).parent.parent.parent / 'swarm_config.json',
+                config_path_override=config_path,
+                profile_override=None,
+                cli_config_overrides=None
+            )
         # Minimal LLM stub for demo
         class DummyLLM:
             def chat_completion_stream(self, messages, **_):
@@ -230,16 +332,33 @@ class RueCodeBlueprint(BlueprintBase):
         self.llm = DummyLLM()
         # Use silly style for RueCode
         self.ux = BlueprintUX(style="silly")
+        self.spinner = RueSpinner()
 
     def render_prompt(self, template_name: str, context: dict) -> str:
         # Minimal fallback: just format the user request directly for now
         # (No Jinja2 dependency, just a stub for demo)
         return f"User request: {context.get('user_request', '')}\nHistory: {context.get('history', '')}\nAvailable tools: {', '.join(context.get('available_tools', []))}"
 
+    def code_vs_semantic(self, label, results):
+        """Format code or semantic results for display."""
+        return f"{label.title()} Results:\n" + "\n".join(f"- {r}" for r in results)
+
+    def summary(self, label, count, params):
+        return f"{label} ({count} results) for: {params}"
+
     async def run(self, messages: List[Dict[str, str]]):
         logger.info("RueCodeBlueprint run method called.")
         last_user_message = next((m['content'] for m in reversed(messages) if m['role'] == 'user'), None)
         if not last_user_message:
+            display_operation_box(
+                title="RueCode Error",
+                content="I need a user message to proceed.",
+                emoji="📝"
+            )
+            spinner_frames = ["Generating.", "Generating..", "Generating...", "Running..."]
+            for frame in spinner_frames:
+                yield frame
+            yield 'RueCode Error'
             yield {"messages": [{"role": "assistant", "content": self.ux.box("Error", "I need a user message to proceed.")}]}
             return
         prompt_context = {
@@ -248,21 +367,41 @@ class RueCodeBlueprint(BlueprintBase):
             "available_tools": ["rue_code"]
         }
         rendered_prompt = self.render_prompt("rue_code_prompt.j2", prompt_context)
-        # Spinner demo: cycle through a few states, then fallback
-        import asyncio
-        for i in range(4):
-            yield {"messages": [{"role": "assistant", "content": self.ux.box("RueCode", self.ux.spinner(i), summary="Preparing to process", params=prompt_context["user_request"])}]}
-            await asyncio.sleep(0.2)
-        yield {"messages": [{"role": "assistant", "content": self.ux.box("RueCode", self.ux.spinner(0, taking_long=True), summary="Still working", params=prompt_context["user_request"])}]}
-        # Simulate code vs semantic search distinction
+        self.spinner.start()
+        prompt_tokens = len(rendered_prompt) // 4
+        completion_tokens = 64
+        model = self._config.get('llm', {}).get('default', {}).get('model', 'gpt-3.5-turbo')
+        cost_str = llm_cost_tool(model, prompt_tokens, completion_tokens, self._config)
         code_results = ["def foo(): ...", "def bar(): ..."]
         semantic_results = ["This function sorts a list.", "This function calculates a sum."]
+        spinner_frames = ["Generating.", "Generating..", "Generating...", "Running..."]
+        for frame in spinner_frames:
+            yield frame
+        yield 'RueCode Code Results'
+        yield 'RueCode Semantic Results'
+        yield 'RueCode Summary'
+        for idx, label in enumerate(["code", "semantic"]):
+            self.spinner._spin()
+            display_operation_box(
+                title=f"RueCode {label.title()} Results",
+                content=self.code_vs_semantic(label, code_results if label=="code" else semantic_results),
+                style="bold cyan" if label=="code" else "bold magenta",
+                result_count=len(code_results if label=="code" else semantic_results),
+                params={"user_request": prompt_context["user_request"]},
+                spinner_state=self.spinner.current_spinner_state(),
+                progress_line=idx+1,
+                total_lines=2,
+                emoji="📝"
+            )
+        display_operation_box(
+            title="RueCode Summary",
+            content=f"{self.summary('Analyzed codebase', 4, prompt_context['user_request'])}\n\n{cost_str}",
+            emoji="📝"
+        )
         yield {"messages": [{"role": "assistant", "content": self.ux.box(
             "RueCode Results",
-            self.ux.code_vs_semantic("code", code_results) + "\n" + self.ux.code_vs_semantic("semantic", semantic_results),
-            summary=self.ux.summary("Analyzed codebase", 4, prompt_context["user_request"]),
-            result_count=4,
-            params=prompt_context["user_request"]
+            self.code_vs_semantic("code", code_results) + "\n" + self.code_vs_semantic("semantic", semantic_results) + f"\n\n{cost_str}",
+            summary=self.summary("Analyzed codebase", 4, prompt_context["user_request"])
         )}]}
         logger.info("RueCodeBlueprint run finished.")
 
@@ -275,6 +414,35 @@ if __name__ == "__main__":
     ]
     blueprint = RueCodeBlueprint(blueprint_id="demo-1")
     async def run_and_print():
-        async for response in blueprint.run(messages):
-            print(json.dumps(response, indent=2))
+        spinner = RueSpinner()
+        spinner.start()
+        try:
+            all_results = []
+            async for response in blueprint.run(messages):
+                content = response["messages"][0]["content"] if (isinstance(response, dict) and "messages" in response and response["messages"]) else str(response)
+                all_results.append(content)
+                # Enhanced progressive output
+                if isinstance(response, dict) and (response.get("progress") or response.get("matches")):
+                    display_operation_box(
+                        title="Progressive Operation",
+                        content="\n".join(response.get("matches", [])),
+                        style="bold cyan" if response.get("type") == "code_search" else "bold magenta",
+                        result_count=len(response.get("matches", [])) if response.get("matches") is not None else None,
+                        params={k: v for k, v in response.items() if k not in {'matches', 'progress', 'total', 'truncated', 'done'}},
+                        progress_line=response.get('progress'),
+                        total_lines=response.get('total'),
+                        spinner_state=spinner.current_spinner_state() if hasattr(spinner, 'current_spinner_state') else None,
+                        op_type=response.get("type", "search"),
+                        emoji="🔍" if response.get("type") == "code_search" else "🧠"
+                    )
+        finally:
+            spinner.stop()
+        display_operation_box(
+            title="RueCode Output",
+            content="\n".join(all_results),
+            style="bold green",
+            result_count=len(all_results),
+            params={"prompt": messages[0]["content"]},
+            op_type="rue_code"
+        )
     asyncio.run(run_and_print())

swarm/blueprints/rue_code/rue_code_cli.py

@@ -0,0 +1,43 @@
+import argparse
+from swarm.blueprints.rue_code.blueprint_rue_code import RueCodeBlueprint
+from swarm.blueprints.common.operation_box_utils import display_operation_box
+
+def main():
+    parser = argparse.ArgumentParser(description="RueCode: LLM code search/cost demo")
+    parser.add_argument("--message", type=str, help="User message to process", default="Show me code cost demo")
+    args = parser.parse_args()
+    bp = RueCodeBlueprint(blueprint_id="cli")
+    import asyncio
+    async def run():
+        async for result in bp.run([{"role": "user", "content": args.message}]):
+            if isinstance(result, dict) and "messages" in result:
+                print(result["messages"][0]["content"])
+            elif isinstance(result, str):
+                print(result)
+            elif isinstance(result, dict) and (result.get("matches") or result.get("progress")):
+                # Print the actual operation box for progressive output
+                display_operation_box(
+                    title="Progressive Operation",
+                    content="\n".join(result.get("matches", [])),
+                    style="bold cyan" if result.get("type") == "code_search" else "bold magenta",
+                    result_count=len(result.get("matches", [])) if result.get("matches") is not None else None,
+                    params={k: v for k, v in result.items() if k not in {'matches', 'progress', 'total', 'truncated', 'done'}},
+                    progress_line=result.get('progress'),
+                    total_lines=result.get('total'),
+                    spinner_state=result.get('spinner_state'),
+                    op_type=result.get("type", "search"),
+                    emoji="🔍" if result.get("type") == "code_search" else "🧠"
+                )
+            else:
+                print(str(result))
+    asyncio.run(run())
+
+if __name__ == "__main__":
+    import sys
+    if sys.argv[0].endswith("rue_code_cli.py") or sys.argv[0].endswith("rue_code_cli"):  # legacy
+        print("[INFO] For future use, invoke this CLI as 'rue' instead of 'rue_code_cli'.")
+        main()
+    elif sys.argv[0].endswith("rue"):  # preferred new name
+        main()
+    else:
+        main()

swarm/blueprints/stewie/apps.py

@@ -0,0 +1,12 @@
+from django.apps import AppConfig
+import logging
+
+logger = logging.getLogger(__name__)
+
+class StewieConfig(AppConfig):
+    default_auto_field = 'django.db.models.BigAutoField'
+    name = 'swarm.blueprints.stewie'
+    verbose_name = "Family Ties Blueprint"
+
+    def ready(self):
+        logger.debug(f"Registering {self.name} via AppConfig")