kader 0.1.5__py3-none-any.whl → 1.0.0__py3-none-any.whl

cli/app.py

@@ -1,7 +1,9 @@
 """Kader CLI - Modern Vibe Coding CLI with Textual."""
 
 import asyncio
+import atexit
 import threading
+from concurrent.futures import ThreadPoolExecutor
 from importlib.metadata import version as get_version
 from pathlib import Path
 from typing import Optional
@@ -18,18 +20,15 @@ from textual.widgets import (
     Tree,
 )
 
-from kader.agent.agents import ReActAgent
 from kader.memory import (
     FileSessionManager,
     MemoryConfig,
-    SlidingWindowConversationManager,
 )
-from kader.tools import get_default_registry
+from kader.workflows import PlannerExecutorWorkflow
 
 from .utils import (
     DEFAULT_MODEL,
     HELP_TEXT,
-    THEME_NAMES,
 )
 from .widgets import ConversationView, InlineSelector, LoadingSpinner, ModelSelector
 
@@ -51,7 +50,6 @@ Type a message below to start chatting, or use one of the commands:
 
 - `/help` - Show available commands
 - `/models` - View available LLM models
-- `/theme` - Change the color theme
 - `/clear` - Clear the conversation
 - `/save` - Save current session
 - `/load` - Load a saved session
@@ -83,7 +81,6 @@ class KaderApp(App):
     BINDINGS = [
         Binding("ctrl+q", "quit", "Quit"),
         Binding("ctrl+l", "clear", "Clear"),
-        Binding("ctrl+t", "cycle_theme", "Theme"),
         Binding("ctrl+s", "save_session", "Save"),
         Binding("ctrl+r", "refresh_tree", "Refresh"),
         Binding("tab", "focus_next", "Next", show=False),
@@ -92,7 +89,6 @@ class KaderApp(App):
 
     def __init__(self) -> None:
         super().__init__()
-        self._current_theme_index = 0
         self._is_processing = False
         self._current_model = DEFAULT_MODEL
         self._current_session_id: str | None = None
@@ -107,22 +103,79 @@ class KaderApp(App):
         self._model_selector: Optional[ModelSelector] = None
         self._update_info: Optional[str] = None  # Latest version if update available
 
-        self._agent = self._create_agent(self._current_model)
+        # Dedicated thread pool for agent invocation (isolated from default pool)
+        self._agent_executor = ThreadPoolExecutor(
+            max_workers=2, thread_name_prefix="kader_agent"
+        )
+        # Ensure executor is properly shut down on exit
+        atexit.register(self._agent_executor.shutdown, wait=False)
+
+        self._workflow = self._create_workflow(self._current_model)
 
-    def _create_agent(self, model_name: str) -> ReActAgent:
-        """Create a new ReActAgent with the specified model."""
-        registry = get_default_registry()
-        memory = SlidingWindowConversationManager(window_size=10)
-        return ReActAgent(
+    def _create_workflow(self, model_name: str) -> PlannerExecutorWorkflow:
+        """Create a new PlannerExecutorWorkflow with the specified model."""
+        return PlannerExecutorWorkflow(
             name="kader_cli",
-            tools=registry,
-            memory=memory,
             model_name=model_name,
-            use_persistence=True,
             interrupt_before_tool=True,
             tool_confirmation_callback=self._tool_confirmation_callback,
+            direct_execution_callback=self._direct_execution_callback,
+            tool_execution_result_callback=self._tool_execution_result_callback,
+            use_persistence=True,
+            executor_names=["executor"],
+        )
+
+    def _direct_execution_callback(self, message: str, tool_name: str) -> None:
+        """
+        Callback for direct execution tools - called from agent thread.
+
+        Shows a message in the conversation view without blocking for confirmation.
+        """
+        # Schedule message display on main thread
+        self.call_from_thread(self._show_direct_execution_message, message, tool_name)
+
+    def _show_direct_execution_message(self, message: str, tool_name: str) -> None:
+        """Show a direct execution message in the conversation view."""
+        try:
+            conversation = self.query_one("#conversation-view", ConversationView)
+            # User-friendly message showing the tool is executing
+            friendly_message = f"[>] Executing {tool_name}..."
+            conversation.add_message(friendly_message, "assistant")
+            conversation.scroll_end()
+        except Exception:
+            pass
+
+    def _tool_execution_result_callback(
+        self, tool_name: str, success: bool, result: str
+    ) -> None:
+        """
+        Callback for tool execution results - called from agent thread.
+
+        Updates the conversation view with the execution result.
+        """
+        # Schedule result display on main thread
+        self.call_from_thread(
+            self._show_tool_execution_result, tool_name, success, result
         )
 
+    def _show_tool_execution_result(
+        self, tool_name: str, success: bool, result: str
+    ) -> None:
+        """Show the tool execution result in the conversation view."""
+        try:
+            conversation = self.query_one("#conversation-view", ConversationView)
+            if success:
+                # User-friendly success message
+                friendly_message = f"(+) {tool_name} completed successfully"
+            else:
+                # User-friendly error message with truncated result
+                error_preview = result[:100] + "..." if len(result) > 100 else result
+                friendly_message = f"(-) {tool_name} failed: {error_preview}"
+            conversation.add_message(friendly_message, "assistant")
+            conversation.scroll_end()
+        except Exception:
+            pass
+
     def _tool_confirmation_callback(self, message: str) -> tuple[bool, Optional[str]]:
         """
         Callback for tool confirmation - called from agent thread.
@@ -139,7 +192,10 @@ class KaderApp(App):
 
         # Wait for user response (blocking in agent thread)
         # This is safe because we're in a background thread
-        self._confirmation_event.wait()
+        # Timeout after 5 minutes to prevent indefinite blocking
+        if not self._confirmation_event.wait(timeout=300):
+            # Timeout occurred - decline tool execution gracefully
+            return (False, "Tool confirmation timed out after 5 minutes")
 
         # Return the result
         return self._confirmation_result
@@ -187,7 +243,8 @@ class KaderApp(App):
         if event.confirmed:
             if tool_message:
                 conversation.add_message(tool_message, "assistant")
-            conversation.add_message("(+) Executing tool...", "assistant")
+            # Show executing message - will be updated by result callback
+            conversation.add_message("[>] Executing tool...", "assistant")
             # Restart spinner
             try:
                 spinner = self.query_one(LoadingSpinner)
@@ -253,7 +310,7 @@ class KaderApp(App):
         # Update model and recreate agent
         old_model = self._current_model
         self._current_model = event.model
-        self._agent = self._create_agent(self._current_model)
+        self._workflow = self._create_workflow(self._current_model)
 
         conversation.add_message(
             f"(+) Model changed from `{old_model}` to `{self._current_model}`",
@@ -433,16 +490,10 @@ Please resize your terminal."""
             conversation.add_message(HELP_TEXT, "assistant")
         elif cmd == "/models":
             await self._show_model_selector(conversation)
-        elif cmd == "/theme":
-            self._cycle_theme()
-            theme_name = THEME_NAMES[self._current_theme_index]
-            conversation.add_message(
-                f"{{~}} Theme changed to **{theme_name}**!", "assistant"
-            )
         elif cmd == "/clear":
             conversation.clear_messages()
-            self._agent.memory.clear()
-            self._agent.provider.reset_tracking()  # Reset usage/cost tracking
+            self._workflow.planner.memory.clear()
+            self._workflow.planner.provider.reset_tracking()  # Reset usage/cost tracking
             self._current_session_id = None
             self.notify("Conversation cleared!", severity="information")
         elif cmd == "/save":
@@ -472,7 +523,7 @@ Please resize your terminal."""
             )
 
     async def _handle_chat(self, message: str) -> None:
-        """Handle regular chat messages with ReActAgent."""
+        """Handle regular chat messages with PlannerExecutorWorkflow."""
         if self._is_processing:
             self.notify("Please wait for the current response...", severity="warning")
             return
@@ -500,16 +551,21 @@ Please resize your terminal."""
         spinner = self.query_one(LoadingSpinner)
 
         try:
-            # Run the agent invoke in a thread
+            # Run the workflow in a dedicated thread pool
             loop = asyncio.get_event_loop()
             response = await loop.run_in_executor(
-                None, lambda: self._agent.invoke(message)
+                self._agent_executor, lambda: self._workflow.run(message)
             )
 
             # Hide spinner and show response (this runs on main thread via await)
             spinner.stop()
-            if response and response.content:
-                conversation.add_message(response.content, "assistant")
+            if response:
+                conversation.add_message(
+                    response,
+                    "assistant",
+                    model_name=self._workflow.planner.provider.model,
+                    usage_cost=self._workflow.planner.provider.total_cost.total_cost,
+                )
 
         except Exception as e:
             spinner.stop()
@@ -522,34 +578,13 @@ Please resize your terminal."""
             # Auto-refresh directory tree in case agent created/modified files
             self._refresh_directory_tree()
 
-    def _cycle_theme(self) -> None:
-        """Cycle through available themes."""
-        # Remove current theme class if it's not dark
-        current_theme = THEME_NAMES[self._current_theme_index]
-        if current_theme != "dark":
-            self.remove_class(f"theme-{current_theme}")
-
-        # Move to next theme
-        self._current_theme_index = (self._current_theme_index + 1) % len(THEME_NAMES)
-        new_theme = THEME_NAMES[self._current_theme_index]
-
-        # Apply new theme class (dark is default, no class needed)
-        if new_theme != "dark":
-            self.add_class(f"theme-{new_theme}")
-
     def action_clear(self) -> None:
         """Clear the conversation (Ctrl+L)."""
         conversation = self.query_one("#conversation-view", ConversationView)
         conversation.clear_messages()
-        self._agent.memory.clear()
+        self._workflow.planner.memory.clear()
         self.notify("Conversation cleared!", severity="information")
 
-    def action_cycle_theme(self) -> None:
-        """Cycle theme (Ctrl+T)."""
-        self._cycle_theme()
-        theme_name = THEME_NAMES[self._current_theme_index]
-        self.notify(f"Theme: {theme_name}", severity="information")
-
     def action_save_session(self) -> None:
         """Save session (Ctrl+S)."""
         conversation = self.query_one("#conversation-view", ConversationView)
@@ -579,8 +614,10 @@ Please resize your terminal."""
                 session = self._session_manager.create_session("kader_cli")
                 self._current_session_id = session.session_id
 
-            # Get messages from agent memory and save
-            messages = [msg.message for msg in self._agent.memory.get_messages()]
+            # Get messages from planner memory and save
+            messages = [
+                msg.message for msg in self._workflow.planner.memory.get_messages()
+            ]
             self._session_manager.save_conversation(self._current_session_id, messages)
 
             conversation.add_message(
@@ -611,11 +648,11 @@ Please resize your terminal."""
 
             # Clear current state
             conversation.clear_messages()
-            self._agent.memory.clear()
+            self._workflow.planner.memory.clear()
 
             # Add loaded messages to memory and UI
             for msg in messages:
-                self._agent.memory.add_message(msg)
+                self._workflow.planner.memory.add_message(msg)
                 role = msg.get("role", "user")
                 content = msg.get("content", "")
                 if role in ["user", "assistant"] and content:
@@ -664,9 +701,9 @@ Please resize your terminal."""
         """Display LLM usage costs."""
         try:
             # Get cost and usage from the provider
-            cost = self._agent.provider.total_cost
-            usage = self._agent.provider.total_usage
-            model = self._agent.provider.model
+            cost = self._workflow.planner.provider.total_cost
+            usage = self._workflow.planner.provider.total_usage
+            model = self._workflow.planner.provider.model
 
             lines = [
                 "## Usage Costs ($)\n",