tunacode-cli 0.0.17__py3-none-any.whl → 0.0.19__py3-none-any.whl

tunacode/cli/commands.py

@@ -6,7 +6,6 @@ from enum import Enum
 from typing import Any, Dict, List, Optional, Type
 
 from .. import utils
-from ..configuration.models import ModelRegistry
 from ..exceptions import ValidationError
 from ..types import CommandArgs, CommandContext, CommandResult, ProcessRequestCallback
 from ..ui import console as ui
@@ -116,9 +115,9 @@ class YoloCommand(SimpleCommand):
         state = context.state_manager.session
         state.yolo = not state.yolo
         if state.yolo:
-            await ui.success("Ooh shit, its YOLO time!\n")
+            await ui.success("All tools are now active ⚡ Please proceed with caution.\n")
         else:
-            await ui.info("Pfft, boring...\n")
+            await ui.info("Tool confirmations re-enabled for safety.\n")
 
 
 class DumpCommand(SimpleCommand):
@@ -168,6 +167,39 @@ class ThoughtsCommand(SimpleCommand):
         await ui.success(f"Thought display {status}")
 
 
+class ArchitectCommand(SimpleCommand):
+    """Toggle architect mode for task planning and orchestration."""
+
+    def __init__(self):
+        super().__init__(
+            CommandSpec(
+                name="architect",
+                aliases=["/architect"],
+                description="Toggle architect mode (task planning & orchestration)",
+                category=CommandCategory.DEBUG,
+            )
+        )
+
+    async def execute(self, args: List[str], context: CommandContext) -> None:
+        state = context.state_manager.session
+        if args:
+            arg = args[0].lower()
+            if arg in {"on", "1", "true"}:
+                state.architect_mode = True
+            elif arg in {"off", "0", "false"}:
+                state.architect_mode = False
+            else:
+                await ui.error("Usage: /architect [on|off]")
+                return
+        else:
+            state.architect_mode = not getattr(state, 'architect_mode', False)
+        status = "ON" if state.architect_mode else "OFF"
+        if state.architect_mode:
+            await ui.success(f"Architect mode {status} - Requests will be planned before execution")
+        else:
+            await ui.success(f"Architect mode {status} - Using direct execution")
+
+
 class IterationsCommand(SimpleCommand):
     """Configure maximum agent iterations for ReAct reasoning."""
 
@@ -189,12 +221,12 @@ class IterationsCommand(SimpleCommand):
                 if new_limit < 1 or new_limit > 50:
                     await ui.error("Iterations must be between 1 and 50")
                     return
-                
+
                 # Update the user config
                 if "settings" not in state.user_config:
                     state.user_config["settings"] = {}
                 state.user_config["settings"]["max_iterations"] = new_limit
-                
+
                 await ui.success(f"Maximum iterations set to {new_limit}")
                 await ui.muted("Higher values allow more complex reasoning but may be slower")
             except ValueError:
@@ -221,8 +253,9 @@ class ClearCommand(SimpleCommand):
     async def execute(self, args: List[str], context: CommandContext) -> None:
         # Patch any orphaned tool calls before clearing
         from tunacode.core.agents.main import patch_tool_messages
+
         patch_tool_messages("Conversation cleared", context.state_manager)
-        
+
         await ui.clear()
         context.state_manager.session.messages = []
         await ui.success("Message history cleared")
@@ -243,17 +276,17 @@ class FixCommand(SimpleCommand):
 
     async def execute(self, args: List[str], context: CommandContext) -> None:
         from tunacode.core.agents.main import patch_tool_messages
-        
+
         # Count current messages
         before_count = len(context.state_manager.session.messages)
-        
+
         # Patch orphaned tool calls
         patch_tool_messages("Tool call resolved by /fix command", context.state_manager)
-        
+
         # Count after patching
         after_count = len(context.state_manager.session.messages)
         patched_count = after_count - before_count
-        
+
         if patched_count > 0:
             await ui.success(f"Fixed {patched_count} orphaned tool call(s)")
             await ui.muted("You can now continue the conversation normally")
@@ -269,36 +302,37 @@ class ParseToolsCommand(SimpleCommand):
             CommandSpec(
                 name="parsetools",
                 aliases=["/parsetools"],
-                description="Parse JSON tool calls from last response when structured calling fails",
+                description=(
+                    "Parse JSON tool calls from last response when structured calling fails"
+                ),
                 category=CommandCategory.DEBUG,
             )
         )
 
     async def execute(self, args: List[str], context: CommandContext) -> None:
         from tunacode.core.agents.main import extract_and_execute_tool_calls
-        
+
         # Find the last model response in messages
         messages = context.state_manager.session.messages
         if not messages:
             await ui.error("No message history found")
             return
-        
+
         # Look for the most recent response with text content
         found_content = False
         for msg in reversed(messages):
-            if hasattr(msg, 'parts'):
+            if hasattr(msg, "parts"):
                 for part in msg.parts:
-                    if hasattr(part, 'content') and isinstance(part.content, str):
+                    if hasattr(part, "content") and isinstance(part.content, str):
                         # Create tool callback
                         from tunacode.cli.repl import _tool_handler
+
                         def tool_callback_with_state(part, node):
                             return _tool_handler(part, node, context.state_manager)
-                        
+
                         try:
                             await extract_and_execute_tool_calls(
-                                part.content, 
-                                tool_callback_with_state, 
-                                context.state_manager
+                                part.content, tool_callback_with_state, context.state_manager
                             )
                             await ui.success("JSON tool parsing completed")
                             found_content = True
@@ -306,7 +340,7 @@ class ParseToolsCommand(SimpleCommand):
                         except Exception as e:
                             await ui.error(f"Failed to parse tools: {str(e)}")
                             return
-        
+
         if not found_content:
             await ui.error("No parseable content found in recent messages")
 
@@ -326,7 +360,7 @@ class RefreshConfigCommand(SimpleCommand):
 
     async def execute(self, args: List[str], context: CommandContext) -> None:
         from tunacode.configuration.defaults import DEFAULT_USER_CONFIG
-        
+
         # Update current session config with latest defaults
         for key, value in DEFAULT_USER_CONFIG.items():
             if key not in context.state_manager.session.user_config:
@@ -336,9 +370,11 @@ class RefreshConfigCommand(SimpleCommand):
                 for subkey, subvalue in value.items():
                     if subkey not in context.state_manager.session.user_config[key]:
                         context.state_manager.session.user_config[key][subkey] = subvalue
-        
+
         # Show updated max_iterations
-        max_iterations = context.state_manager.session.user_config.get("settings", {}).get("max_iterations", 20)
+        max_iterations = context.state_manager.session.user_config.get("settings", {}).get(
+            "max_iterations", 20
+        )
         await ui.success(f"Configuration refreshed - max iterations: {max_iterations}")
 
 
@@ -507,23 +543,20 @@ class UpdateCommand(SimpleCommand):
         )
 
     async def execute(self, args: List[str], context: CommandContext) -> None:
+        import shutil
         import subprocess
         import sys
-        import shutil
 
         await ui.info("Checking for TunaCode updates...")
 
         # Detect installation method
         installation_method = None
-        
+
         # Check if installed via pipx
         if shutil.which("pipx"):
             try:
                 result = subprocess.run(
-                    ["pipx", "list"], 
-                    capture_output=True, 
-                    text=True, 
-                    timeout=10
+                    ["pipx", "list"], capture_output=True, text=True, timeout=10
                 )
                 if "tunacode" in result.stdout.lower():
                     installation_method = "pipx"
@@ -534,10 +567,10 @@ class UpdateCommand(SimpleCommand):
         if not installation_method:
             try:
                 result = subprocess.run(
-                    [sys.executable, "-m", "pip", "show", "tunacode-cli"], 
-                    capture_output=True, 
-                    text=True, 
-                    timeout=10
+                    [sys.executable, "-m", "pip", "show", "tunacode-cli"],
+                    capture_output=True,
+                    text=True,
+                    timeout=10,
                 )
                 if result.returncode == 0:
                     installation_method = "pip"
@@ -556,10 +589,7 @@ class UpdateCommand(SimpleCommand):
             if installation_method == "pipx":
                 await ui.info("Updating via pipx...")
                 result = subprocess.run(
-                    ["pipx", "upgrade", "tunacode"],
-                    capture_output=True,
-                    text=True,
-                    timeout=60
+                    ["pipx", "upgrade", "tunacode"], capture_output=True, text=True, timeout=60
                 )
             else:  # pip
                 await ui.info("Updating via pip...")
@@ -567,16 +597,16 @@ class UpdateCommand(SimpleCommand):
                     [sys.executable, "-m", "pip", "install", "--upgrade", "tunacode-cli"],
                     capture_output=True,
                     text=True,
-                    timeout=60
+                    timeout=60,
                 )
 
             if result.returncode == 0:
                 await ui.success("TunaCode updated successfully!")
                 await ui.muted("Restart TunaCode to use the new version")
-                
+
                 # Show update output if available
                 if result.stdout.strip():
-                    output_lines = result.stdout.strip().split('\n')
+                    output_lines = result.stdout.strip().split("\n")
                     for line in output_lines[-5:]:  # Show last 5 lines
                         if line.strip():
                             await ui.muted(f"  {line}")
@@ -723,6 +753,7 @@ class CommandRegistry:
             YoloCommand,
             DumpCommand,
             ThoughtsCommand,
+            ArchitectCommand,
             IterationsCommand,
             ClearCommand,
             FixCommand,
@@ -798,8 +829,9 @@ class CommandRegistry:
             return await command.execute(args, context)
         else:
             # Ambiguous - show possibilities
+            matches_str = ", ".join(sorted(set(matches)))
             raise ValidationError(
-                f"Ambiguous command '{command_name}'. Did you mean: {', '.join(sorted(set(matches)))}?"
+                f"Ambiguous command '{command_name}'. Did you mean: {matches_str}?"
             )
 
     def find_matching_commands(self, partial_command: str) -> List[str]:

tunacode/cli/main.py

@@ -24,36 +24,39 @@ state_manager = StateManager()
 def main(
     version: bool = typer.Option(False, "--version", "-v", help="Show version and exit."),
     run_setup: bool = typer.Option(False, "--setup", help="Run setup process."),
-    baseurl: str = typer.Option(None, "--baseurl", help="API base URL (e.g., https://openrouter.ai/api/v1)"),
+    baseurl: str = typer.Option(
+        None, "--baseurl", help="API base URL (e.g., https://openrouter.ai/api/v1)"
+    ),
     model: str = typer.Option(None, "--model", help="Default model to use (e.g., openai/gpt-4)"),
     key: str = typer.Option(None, "--key", help="API key for the provider"),
 ):
     """🚀 Start TunaCode - Your AI-powered development assistant"""
-    
-    if version:
-        asyncio.run(ui.version())
-        return
-
-    asyncio.run(ui.banner())
-
-    has_update, latest_version = check_for_updates()
-    if has_update:
-        asyncio.run(ui.show_update_message(latest_version))
-
-    # Pass CLI args to setup
-    cli_config = {}
-    if baseurl or model or key:
-        cli_config = {
-            "baseurl": baseurl,
-            "model": model,
-            "key": key
-        }
-
-    try:
-        asyncio.run(setup(run_setup, state_manager, cli_config))
-        asyncio.run(repl(state_manager))
-    except Exception as e:
-        asyncio.run(ui.error(str(e)))
+
+    async def async_main():
+        if version:
+            await ui.version()
+            return
+
+        await ui.banner()
+
+        # Start update check in background
+        update_task = asyncio.to_thread(check_for_updates)
+
+        cli_config = {}
+        if baseurl or model or key:
+            cli_config = {"baseurl": baseurl, "model": model, "key": key}
+
+        try:
+            await setup(run_setup, state_manager, cli_config)
+            await repl(state_manager)
+        except Exception as e:
+            await ui.error(str(e))
+
+        has_update, latest_version = await update_task
+        if has_update:
+            await ui.update_available(latest_version)
+
+    asyncio.run(async_main())
 
 
 if __name__ == "__main__":

tunacode/cli/repl.py

@@ -6,6 +6,8 @@ Handles user input, command processing, and agent interaction in an interactive
 """
 
 import json
+import os
+import subprocess
 from asyncio.exceptions import CancelledError
 
 from prompt_toolkit.application import run_in_terminal
@@ -15,6 +17,7 @@ from pydantic_ai.exceptions import UnexpectedModelBehavior
 from tunacode.configuration.settings import ApplicationSettings
 from tunacode.core.agents import main as agent
 from tunacode.core.agents.main import patch_tool_messages
+from tunacode.core.agents.orchestrator import OrchestratorAgent
 from tunacode.core.tool_handler import ToolHandler
 from tunacode.exceptions import AgentError, UserAbortError, ValidationError
 from tunacode.ui import console as ui
@@ -158,41 +161,69 @@ async def process_request(text: str, state_manager: StateManager, output: bool =
         True, state_manager.session.spinner, state_manager
     )
     try:
-        # Expand @file references before sending to the agent
-        try:
-            from tunacode.utils.text_utils import expand_file_refs
-
-            text = expand_file_refs(text)
-        except ValueError as e:
-            await ui.error(str(e))
-            return
-
         # Patch any orphaned tool calls from previous requests before proceeding
         patch_tool_messages("Tool execution was interrupted", state_manager)
-        
+
+        # Track message start for thoughts display
+        start_idx = len(state_manager.session.messages)
+
         # Create a partial function that includes state_manager
         def tool_callback_with_state(part, node):
             return _tool_handler(part, node, state_manager)
 
-        start_idx = len(state_manager.session.messages)
-        res = await agent.process_request(
-            state_manager.session.current_model,
-            text,
-            state_manager,
-            tool_callback=tool_callback_with_state,
-        )
-        if output:
-            if state_manager.session.show_thoughts:
-                new_msgs = state_manager.session.messages[start_idx:]
-                for msg in new_msgs:
-                    if isinstance(msg, dict) and "thought" in msg:
-                        await ui.muted(f"THOUGHT: {msg['thought']}")
-            # Check if result exists and has output
-            if hasattr(res, 'result') and res.result is not None and hasattr(res.result, 'output'):
-                await ui.agent(res.result.output)
-            else:
-                # Fallback: show that the request was processed
-                await ui.muted("Request completed")
+        # Check if architect mode is enabled
+        if getattr(state_manager.session, 'architect_mode', False):
+            # Expand @file references before sending to the orchestrator
+            try:
+                from tunacode.utils.text_utils import expand_file_refs
+
+                text = expand_file_refs(text)
+            except ValueError as e:
+                await ui.error(str(e))
+                return
+            # Use orchestrator for planning and execution
+            orchestrator = OrchestratorAgent(state_manager)
+            results = await orchestrator.run(text, state_manager.session.current_model)
+            
+            if output:
+                # Process results from all sub-agents
+                for res in results:
+                    # Check if result exists and has output
+                    if hasattr(res, "result") and res.result is not None and hasattr(res.result, "output"):
+                        await ui.agent(res.result.output)
+                
+                if not results:
+                    # Fallback: show that the request was processed
+                    await ui.muted("Request completed")
+        else:
+            # Expand @file references before sending to the agent
+            try:
+                from tunacode.utils.text_utils import expand_file_refs
+
+                text = expand_file_refs(text)
+            except ValueError as e:
+                await ui.error(str(e))
+                return
+            
+            # Use normal agent processing
+            res = await agent.process_request(
+                state_manager.session.current_model,
+                text,
+                state_manager,
+                tool_callback=tool_callback_with_state,
+            )
+            if output:
+                if state_manager.session.show_thoughts:
+                    new_msgs = state_manager.session.messages[start_idx:]
+                    for msg in new_msgs:
+                        if isinstance(msg, dict) and "thought" in msg:
+                            await ui.muted(f"THOUGHT: {msg['thought']}")
+                # Check if result exists and has output
+                if hasattr(res, "result") and res.result is not None and hasattr(res.result, "output"):
+                    await ui.agent(res.result.output)
+                else:
+                    # Fallback: show that the request was processed
+                    await ui.muted("Request completed")
     except CancelledError:
         await ui.muted("Request cancelled")
     except UserAbortError:
@@ -204,29 +235,28 @@ async def process_request(text: str, state_manager: StateManager, output: bool =
     except Exception as e:
         # Check if this might be a tool calling failure that we can recover from
         error_str = str(e).lower()
-        if any(keyword in error_str for keyword in ['tool', 'function', 'call', 'schema']):
+        if any(keyword in error_str for keyword in ["tool", "function", "call", "schema"]):
             # Try to extract and execute tool calls from the last response
             if state_manager.session.messages:
                 last_msg = state_manager.session.messages[-1]
-                if hasattr(last_msg, 'parts'):
+                if hasattr(last_msg, "parts"):
                     for part in last_msg.parts:
-                        if hasattr(part, 'content') and isinstance(part.content, str):
+                        if hasattr(part, "content") and isinstance(part.content, str):
                             from tunacode.core.agents.main import extract_and_execute_tool_calls
+
                             try:
                                 # Create a partial function that includes state_manager
                                 def tool_callback_with_state(part, node):
                                     return _tool_handler(part, node, state_manager)
-                                    
+
                                 await extract_and_execute_tool_calls(
-                                    part.content, 
-                                    tool_callback_with_state, 
-                                    state_manager
+                                    part.content, tool_callback_with_state, state_manager
                                 )
                                 await ui.warning("🔧 Recovered using JSON tool parsing")
                                 return  # Successfully recovered
                             except Exception:
                                 pass  # Fallback failed, continue with normal error handling
-        
+
         # Wrap unexpected exceptions in AgentError for better tracking
         agent_error = AgentError(f"Agent processing failed: {str(e)}")
         agent_error.__cause__ = e  # Preserve the original exception chain
@@ -271,6 +301,30 @@ async def repl(state_manager: StateManager):
                     break
                 continue
 
+            if line.startswith("!"):
+                command = line[1:].strip()
+
+                # Show tool-style header for bash commands
+                cmd_display = command if command else "Interactive shell"
+                await ui.panel("Tool(bash)", f"Command: {cmd_display}", border_style="yellow")
+
+                def run_shell():
+                    try:
+                        if command:
+                            result = subprocess.run(command, shell=True, capture_output=False)
+                            if result.returncode != 0:
+                                # Use print directly since we're in a terminal context
+                                print(f"\nCommand exited with code {result.returncode}")
+                        else:
+                            shell = os.environ.get("SHELL", "bash")
+                            subprocess.run(shell)
+                    except Exception as e:
+                        print(f"\nShell command failed: {str(e)}")
+
+                await run_in_terminal(run_shell)
+                await ui.line()
+                continue
+
             # Check if another task is already running
             if state_manager.session.current_task and not state_manager.session.current_task.done():
                 await ui.muted("Agent is busy, press Ctrl+C to interrupt.")