kader 0.1.6__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,13 +20,11 @@ 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,
@@ -103,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.
@@ -135,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
@@ -183,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)
@@ -249,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}`",
@@ -431,8 +492,8 @@ Please resize your terminal."""
             await self._show_model_selector(conversation)
         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":
@@ -462,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
@@ -490,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()
@@ -516,7 +582,7 @@ Please resize your terminal."""
         """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_save_session(self) -> None:
@@ -548,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(
@@ -580,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:
@@ -633,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",

cli/app.tcss

@@ -132,6 +132,26 @@ ConversationView {
     scrollbar-size: 1 1;
 }
 
+.message-footer {
+    height: auto;
+    margin-top: 0;
+    padding: 0 1;
+    border-top: none;
+}
+
+.footer-left {
+    color: $secondary;
+    text-style: italic;
+    width: 1fr;
+}
+
+.footer-right {
+    color: $success;
+    text-style: bold;
+    text-align: right;
+    width: auto;
+}
+
 /* ===== Welcome Message ===== */
 
 #welcome {

cli/utils.py

@@ -3,7 +3,7 @@
 from kader.providers import OllamaProvider
 
 # Default model
-DEFAULT_MODEL = "qwen3-coder:480b-cloud"
+DEFAULT_MODEL = "kimi-k2.5:cloud"
 
 HELP_TEXT = """## Kader CLI Commands
 

cli/widgets/conversation.py

@@ -1,23 +1,43 @@
 """Conversation display widget for Kader CLI."""
 
 from textual.app import ComposeResult
-from textual.containers import VerticalScroll
+from textual.containers import Horizontal, VerticalScroll
 from textual.widgets import Markdown, Static
 
 
 class Message(Static):
     """A single message in the conversation."""
 
-    def __init__(self, content: str, role: str = "user") -> None:
+    def __init__(
+        self,
+        content: str,
+        role: str = "user",
+        model_name: str | None = None,
+        usage_cost: float | None = None,
+    ) -> None:
         super().__init__()
         self.content = content
         self.role = role
+        self.model_name = model_name
+        self.usage_cost = usage_cost
         self.add_class(f"message-{role}")
 
     def compose(self) -> ComposeResult:
         prefix = "(**) **You:**" if self.role == "user" else "(^^) **Kader:**"
         yield Markdown(f"{prefix}\n\n{self.content}")
 
+        if self.role == "assistant" and (
+            self.model_name or self.usage_cost is not None
+        ):
+            with Horizontal(classes="message-footer"):
+                model_label = f"[*] {self.model_name}" if self.model_name else ""
+                yield Static(model_label, classes="footer-left")
+
+                usage_label = (
+                    f"($) {self.usage_cost:.6f}" if self.usage_cost is not None else ""
+                )
+                yield Static(usage_label, classes="footer-right")
+
 
 class ConversationView(VerticalScroll):
     """Scrollable conversation history with markdown rendering."""
@@ -41,11 +61,37 @@ class ConversationView(VerticalScroll):
         background: $surface-darken-1;
         border-left: thick $success;
     }
+
+    .message-footer {
+        height: auto;
+        margin-top: 0;
+        padding: 0 1;
+        border-top: none;
+    }
+
+    .footer-left {
+        color: $secondary;
+        text-style: italic;
+        width: 1fr;
+    }
+
+    .footer-right {
+        color: $success;
+        text-style: bold;
+        text-align: right;
+        width: auto;
+    }
     """
 
-    def add_message(self, content: str, role: str = "user") -> None:
+    def add_message(
+        self,
+        content: str,
+        role: str = "user",
+        model_name: str | None = None,
+        usage_cost: float | None = None,
+    ) -> None:
         """Add a message to the conversation."""
-        message = Message(content, role)
+        message = Message(content, role, model_name, usage_cost)
         self.mount(message)
         self.scroll_end(animate=True)
 

kader/__init__.py

@@ -8,6 +8,7 @@ creating the .kader directory in the user's home directory.
 from .config import ENV_FILE_PATH, KADER_DIR, initialize_kader_config
 from .providers import *  # noqa: F401, F403
 from .tools import *  # noqa: F401, F403
+from .utils import Checkpointer
 
 # Initialize the configuration when the module is imported
 initialize_kader_config()
@@ -18,5 +19,6 @@ __all__ = [
     "KADER_DIR",
     "ENV_FILE_PATH",
     "initialize_kader_config",
+    "Checkpointer",
     # Export everything from providers and tools
 ]

kader/agent/agents.py

@@ -31,6 +31,8 @@ class ReActAgent(BaseAgent):
         use_persistence: bool = False,
         interrupt_before_tool: bool = True,
         tool_confirmation_callback: Optional[callable] = None,
+        direct_execution_callback: Optional[callable] = None,
+        tool_execution_result_callback: Optional[callable] = None,
     ) -> None:
         # Resolve tools for prompt context if necessary
         # The base agent handles tool registration, but for the prompt template
@@ -67,6 +69,8 @@ class ReActAgent(BaseAgent):
             use_persistence=use_persistence,
             interrupt_before_tool=interrupt_before_tool,
             tool_confirmation_callback=tool_confirmation_callback,
+            direct_execution_callback=direct_execution_callback,
+            tool_execution_result_callback=tool_execution_result_callback,
         )
 
 
@@ -90,6 +94,8 @@ class PlanningAgent(BaseAgent):
         use_persistence: bool = False,
         interrupt_before_tool: bool = True,
         tool_confirmation_callback: Optional[callable] = None,
+        direct_execution_callback: Optional[callable] = None,
+        tool_execution_result_callback: Optional[callable] = None,
     ) -> None:
         # Ensure TodoTool is available
         _todo_tool = TodoTool()
@@ -123,4 +129,6 @@ class PlanningAgent(BaseAgent):
             use_persistence=use_persistence,
             interrupt_before_tool=interrupt_before_tool,
             tool_confirmation_callback=tool_confirmation_callback,
+            direct_execution_callback=direct_execution_callback,
+            tool_execution_result_callback=tool_execution_result_callback,
         )

kader/agent/base.py

@@ -48,11 +48,15 @@ class BaseAgent:
         provider: Optional[BaseLLMProvider] = None,
         memory: Optional[ConversationManager] = None,
         retry_attempts: int = 3,
+        retry_wait_min: int = 1,
+        retry_wait_max: int = 5,
         model_name: str = "qwen3-coder:480b-cloud",
         session_id: Optional[str] = None,
         use_persistence: bool = False,
         interrupt_before_tool: bool = True,
         tool_confirmation_callback: Optional[callable] = None,
+        direct_execution_callback: Optional[callable] = None,
+        tool_execution_result_callback: Optional[callable] = None,
     ) -> None:
         """
         Initialize the Base Agent.
@@ -75,8 +79,12 @@ class BaseAgent:
         self.name = name
         self.system_prompt = system_prompt
         self.retry_attempts = retry_attempts
+        self.retry_wait_min = retry_wait_min
+        self.retry_wait_max = retry_wait_max
         self.interrupt_before_tool = interrupt_before_tool
         self.tool_confirmation_callback = tool_confirmation_callback
+        self.direct_execution_callback = direct_execution_callback
+        self.tool_execution_result_callback = tool_execution_result_callback
 
         # Persistence Configuration
         self.session_id = session_id
@@ -339,6 +347,31 @@ class BaseAgent:
         if llm_content and len(llm_content) > 0:
             display_str = f"{llm_content}\n\n{display_str}"
 
+        # Extract tool name for direct execution check
+        fn_info = tool_call_dict.get("function", {})
+        if not fn_info and "name" in tool_call_dict:
+            fn_info = tool_call_dict
+        tool_name = fn_info.get("name", "")
+
+        # List of tools to execute directly (show message but don't ask for confirmation)
+        direct_execution_tools = {
+            "read_file",
+            "glob",
+            "grep",
+            "read_directory",
+            "read_dir",
+        }
+
+        # Direct execution for specific tools - applies regardless of callback
+        if tool_name in direct_execution_tools:
+            # Notify via direct_execution_callback if available (for CLI/TUI display)
+            if self.direct_execution_callback:
+                self.direct_execution_callback(display_str, tool_name)
+            else:
+                # Fallback: print to console
+                print(display_str)
+            return True, None
+
         # Use callback if provided (e.g., for GUI/TUI)
         if self.tool_confirmation_callback:
             return self.tool_confirmation_callback(display_str)
@@ -435,6 +468,18 @@ class BaseAgent:
                 # Execute tool
                 tool_result = self._tool_registry.run(tool_call)
 
+                # Notify about tool execution result if callback available
+                if self.tool_execution_result_callback:
+                    # Handle both enum and string status
+                    status = tool_result.status
+                    status_value = (
+                        status.value if hasattr(status, "value") else str(status)
+                    )
+                    success = status_value == "success"
+                    self.tool_execution_result_callback(
+                        tool_call.name, success, tool_result.content
+                    )
+
                 # add result to memory
                 # But here we just return messages, caller handles memory add
                 tool_msg = Message.tool(
@@ -482,6 +527,18 @@ class BaseAgent:
                 # Execute tool async
                 tool_result = await self._tool_registry.arun(tool_call)
 
+                # Notify about tool execution result if callback available
+                if self.tool_execution_result_callback:
+                    # Handle both enum and string status
+                    status = tool_result.status
+                    status_value = (
+                        status.value if hasattr(status, "value") else str(status)
+                    )
+                    success = status_value == "success"
+                    self.tool_execution_result_callback(
+                        tool_call.name, success, tool_result.content
+                    )
+
                 tool_msg = Message.tool(
                     tool_call_id=tool_result.tool_call_id, content=tool_result.content
                 )
@@ -509,7 +566,9 @@ class BaseAgent:
 
         runner = Retrying(
             stop=stop_after_attempt(self.retry_attempts),
-            wait=wait_exponential(multiplier=1, min=4, max=10),
+            wait=wait_exponential(
+                multiplier=1, min=self.retry_wait_min, max=self.retry_wait_max
+            ),
             reraise=True,
         )
 
@@ -652,7 +711,9 @@ class BaseAgent:
 
         runner = Retrying(
             stop=stop_after_attempt(self.retry_attempts),
-            wait=wait_exponential(multiplier=1, min=4, max=10),
+            wait=wait_exponential(
+                multiplier=1, min=self.retry_wait_min, max=self.retry_wait_max
+            ),
             reraise=True,
         )
 
@@ -689,7 +750,9 @@ class BaseAgent:
 
         runner = AsyncRetrying(
             stop=stop_after_attempt(self.retry_attempts),
-            wait=wait_exponential(multiplier=1, min=4, max=10),
+            wait=wait_exponential(
+                multiplier=1, min=self.retry_wait_min, max=self.retry_wait_max
+            ),
             reraise=True,
         )
 
@@ -905,9 +968,9 @@ class BaseAgent:
         if registry is None:
             # Lazy import to avoid circular dependencies if any
             try:
-                from kader.tools import get_default_registry
+                from kader.tools import get_cached_default_registry
 
-                registry = get_default_registry()
+                registry = get_cached_default_registry()
             except ImportError:
                 pass
 

kader/memory/types.py

@@ -114,3 +114,63 @@ def load_json(path: Path) -> dict[str, Any]:
         return {}
     with open(path, "r", encoding="utf-8") as f:
         return decode_bytes_values(json.load(f))
+
+
+# --- Async File I/O Utilities ---
+
+
+async def aread_text(path: Path, encoding: str = "utf-8") -> str:
+    """Asynchronously read text from a file.
+
+    Args:
+        path: Path to the file
+        encoding: File encoding (default: utf-8)
+
+    Returns:
+        File contents as string
+    """
+    import aiofiles
+
+    async with aiofiles.open(path, "r", encoding=encoding) as f:
+        return await f.read()
+
+
+async def awrite_text(path: Path, content: str, encoding: str = "utf-8") -> None:
+    """Asynchronously write text to a file.
+
+    Args:
+        path: Path to the file
+        content: Text content to write
+        encoding: File encoding (default: utf-8)
+    """
+    import aiofiles
+
+    path.parent.mkdir(parents=True, exist_ok=True)
+    async with aiofiles.open(path, "w", encoding=encoding) as f:
+        await f.write(content)
+
+
+async def asave_json(path: Path, data: dict[str, Any]) -> None:
+    """Asynchronously save data to a JSON file.
+
+    Args:
+        path: Path to the JSON file
+        data: Data to save
+    """
+    content = json.dumps(encode_bytes_values(data), indent=2, ensure_ascii=False)
+    await awrite_text(path, content)
+
+
+async def aload_json(path: Path) -> dict[str, Any]:
+    """Asynchronously load data from a JSON file.
+
+    Args:
+        path: Path to the JSON file
+
+    Returns:
+        Loaded data, or empty dict if file doesn't exist
+    """
+    if not path.exists():
+        return {}
+    content = await aread_text(path)
+    return decode_bytes_values(json.loads(content))

kader/prompts/__init__.py

@@ -1,4 +1,10 @@
-from .agent_prompts import BasicAssistancePrompt, PlanningAgentPrompt, ReActAgentPrompt
+from .agent_prompts import (
+    BasicAssistancePrompt,
+    ExecutorAgentPrompt,
+    KaderPlannerPrompt,
+    PlanningAgentPrompt,
+    ReActAgentPrompt,
+)
 from .base import PromptBase
 
 __all__ = [
@@ -6,4 +12,6 @@ __all__ = [
     "BasicAssistancePrompt",
     "ReActAgentPrompt",
     "PlanningAgentPrompt",
+    "KaderPlannerPrompt",
+    "ExecutorAgentPrompt",
 ]

kader/prompts/agent_prompts.py

@@ -25,3 +25,31 @@ class PlanningAgentPrompt(PromptBase):
 
     def __init__(self, **kwargs: Any) -> None:
         super().__init__(template_path="planning_agent.j2", **kwargs)
+
+
+class KaderPlannerPrompt(PromptBase):
+    """
+    Prompt for Kader Planner Agent.
+
+    Enhanced planning prompt with specific instructions for:
+    - Using Agent as a Tool with proper task/context parameters
+    - Tracking completed actions to avoid repetition
+    """
+
+    def __init__(self, **kwargs: Any) -> None:
+        super().__init__(template_path="kader_planner.j2", **kwargs)
+
+
+class ExecutorAgentPrompt(PromptBase):
+    """
+    Prompt for Executor Agent (sub-agents in PlannerExecutorWorkflow).
+
+    Emphasizes:
+    - Careful thinking before each action
+    - Safe execution with error handling
+    - Detailed step-by-step reporting of what was done
+    - Structured final answer with files created, summary, and issues
+    """
+
+    def __init__(self, **kwargs: Any) -> None:
+        super().__init__(template_path="executor_agent.j2", **kwargs)