kader 0.1.0__py3-none-any.whl

cli/widgets/confirmation.py

@@ -0,0 +1,309 @@
+"""Inline selection widget for tool confirmation and model selection."""
+
+from textual.app import ComposeResult
+from textual.binding import Binding
+from textual.containers import Vertical
+from textual.message import Message as TextualMessage
+from textual.reactive import reactive
+from textual.widget import Widget
+from textual.widgets import Static
+
+
+class InlineSelector(Widget, can_focus=True):
+    """
+    Inline selector widget for Yes/No confirmation.
+
+    Uses arrow keys to navigate, Enter to confirm.
+    """
+
+    BINDINGS = [
+        Binding("up", "move_up", "Up", show=False),
+        Binding("down", "move_down", "Down", show=False),
+        Binding("left", "move_up", "Left", show=False),
+        Binding("right", "move_down", "Right", show=False),
+        Binding("enter", "confirm", "Confirm", show=False),
+        Binding("y", "confirm_yes", "Yes", show=False),
+        Binding("n", "confirm_no", "No", show=False),
+    ]
+
+    DEFAULT_CSS = """
+    InlineSelector {
+        width: 100%;
+        height: auto;
+        padding: 1;
+        border: solid $primary;
+        background: $surface;
+    }
+
+    InlineSelector:focus {
+        border: double $primary;
+    }
+
+    InlineSelector .selector-container {
+        width: 100%;
+        height: auto;
+        align: center middle;
+    }
+
+    InlineSelector .option {
+        padding: 0 3;
+        margin: 0 2;
+        min-width: 12;
+        text-align: center;
+    }
+
+    InlineSelector .option.selected {
+        background: $primary;
+        color: $text;
+        text-style: bold reverse;
+    }
+
+    InlineSelector .option.not-selected {
+        background: $surface-darken-1;
+        color: $text-muted;
+    }
+
+    InlineSelector .prompt-text {
+        margin-bottom: 1;
+        text-align: center;
+        width: 100%;
+        color: $text-muted;
+    }
+
+    InlineSelector .message-text {
+        margin-bottom: 1;
+        text-align: center;
+        width: 100%;
+        color: $warning;
+        text-style: bold;
+    }
+    """
+
+    selected_index: reactive[int] = reactive(0)
+
+    def __init__(self, message: str, options: list[str] = None, **kwargs) -> None:
+        super().__init__(**kwargs)
+        self.message = message
+        self.options = options or ["✅ Yes", "❌ No"]
+
+    def compose(self) -> ComposeResult:
+        from textual.containers import Horizontal
+
+        yield Static(f"🔧 {self.message}", classes="message-text")
+        yield Static(
+            "↑↓ to select • Enter to confirm • Y/N for quick select",
+            classes="prompt-text",
+        )
+        with Horizontal(classes="selector-container"):
+            for i, option in enumerate(self.options):
+                cls = (
+                    "option selected"
+                    if i == self.selected_index
+                    else "option not-selected"
+                )
+                yield Static(option, classes=cls, id=f"option-{i}")
+
+    def on_mount(self) -> None:
+        """Focus self when mounted."""
+        self.focus()
+
+    def watch_selected_index(self, old_index: int, new_index: int) -> None:
+        """Update visual selection when index changes."""
+        try:
+            old_option = self.query_one(f"#option-{old_index}", Static)
+            old_option.remove_class("selected")
+            old_option.add_class("not-selected")
+
+            new_option = self.query_one(f"#option-{new_index}", Static)
+            new_option.remove_class("not-selected")
+            new_option.add_class("selected")
+        except Exception:
+            pass
+
+    def action_move_up(self) -> None:
+        """Move selection up/left."""
+        self.selected_index = (self.selected_index - 1) % len(self.options)
+
+    def action_move_down(self) -> None:
+        """Move selection down/right."""
+        self.selected_index = (self.selected_index + 1) % len(self.options)
+
+    def action_confirm(self) -> None:
+        """Confirm current selection."""
+        self.post_message(self.Confirmed(self.selected_index == 0))
+
+    def action_confirm_yes(self) -> None:
+        """Quick confirm Yes."""
+        self.selected_index = 0
+        self.post_message(self.Confirmed(True))
+
+    def action_confirm_no(self) -> None:
+        """Quick confirm No."""
+        self.selected_index = 1
+        self.post_message(self.Confirmed(False))
+
+    class Confirmed(TextualMessage):
+        """Message sent when user confirms selection."""
+
+        def __init__(self, confirmed: bool) -> None:
+            super().__init__()
+            self.confirmed = confirmed
+
+
+class ModelSelector(Widget, can_focus=True):
+    """
+    Model selector widget for choosing LLM models.
+
+    Uses arrow keys to navigate, Enter to confirm, Escape to cancel.
+    """
+
+    BINDINGS = [
+        Binding("up", "move_up", "Up", show=False),
+        Binding("down", "move_down", "Down", show=False),
+        Binding("enter", "confirm", "Confirm", show=False),
+        Binding("escape", "cancel", "Cancel", show=False),
+    ]
+
+    DEFAULT_CSS = """
+    ModelSelector {
+        width: 100%;
+        height: auto;
+        padding: 1;
+        border: solid $primary;
+        background: $surface;
+    }
+
+    ModelSelector:focus {
+        border: double $primary;
+    }
+
+    ModelSelector .title-text {
+        margin-bottom: 1;
+        text-align: center;
+        width: 100%;
+        color: $warning;
+        text-style: bold;
+    }
+
+    ModelSelector .prompt-text {
+        margin-bottom: 1;
+        text-align: center;
+        width: 100%;
+        color: $text-muted;
+    }
+
+    ModelSelector .model-list {
+        width: 100%;
+        height: auto;
+        max-height: 15;
+    }
+
+    ModelSelector .model-option {
+        padding: 0 2;
+        width: 100%;
+    }
+
+    ModelSelector .model-option.selected {
+        background: $primary;
+        color: $text;
+        text-style: bold;
+    }
+
+    ModelSelector .model-option.not-selected {
+        background: $surface;
+        color: $text-muted;
+    }
+
+    ModelSelector .model-option.current {
+        color: $success;
+    }
+    """
+
+    selected_index: reactive[int] = reactive(0)
+
+    def __init__(self, models: list[str], current_model: str = "", **kwargs) -> None:
+        super().__init__(**kwargs)
+        self.models = models
+        self.current_model = current_model
+        # Start with current model selected if it exists
+        if current_model in models:
+            self.selected_index = models.index(current_model)
+
+    def compose(self) -> ComposeResult:
+        yield Static("🤖 Select Model", classes="title-text")
+        yield Static(
+            "↑↓ to navigate • Enter to select • Esc to cancel", classes="prompt-text"
+        )
+        with Vertical(classes="model-list"):
+            for i, model in enumerate(self.models):
+                is_current = model == self.current_model
+                is_selected = i == self.selected_index
+                classes = "model-option"
+                if is_selected:
+                    classes += " selected"
+                else:
+                    classes += " not-selected"
+                if is_current:
+                    classes += " current"
+                label = f"  ▶ {model}" if is_selected else f"    {model}"
+                if is_current:
+                    label += " (current)"
+                yield Static(label, classes=classes, id=f"model-{i}")
+
+    def on_mount(self) -> None:
+        """Focus self when mounted."""
+        self.focus()
+
+    def watch_selected_index(self, old_index: int, new_index: int) -> None:
+        """Update visual selection when index changes."""
+        try:
+            # Update old option
+            old_option = self.query_one(f"#model-{old_index}", Static)
+            old_option.remove_class("selected")
+            old_option.add_class("not-selected")
+            old_model = self.models[old_index]
+            old_label = f"    {old_model}"
+            if old_model == self.current_model:
+                old_label += " (current)"
+            old_option.update(old_label)
+
+            # Update new option
+            new_option = self.query_one(f"#model-{new_index}", Static)
+            new_option.remove_class("not-selected")
+            new_option.add_class("selected")
+            new_model = self.models[new_index]
+            new_label = f"  ▶ {new_model}"
+            if new_model == self.current_model:
+                new_label += " (current)"
+            new_option.update(new_label)
+        except Exception:
+            pass
+
+    def action_move_up(self) -> None:
+        """Move selection up."""
+        self.selected_index = (self.selected_index - 1) % len(self.models)
+
+    def action_move_down(self) -> None:
+        """Move selection down."""
+        self.selected_index = (self.selected_index + 1) % len(self.models)
+
+    def action_confirm(self) -> None:
+        """Confirm current selection."""
+        selected_model = self.models[self.selected_index]
+        self.post_message(self.ModelSelected(selected_model))
+
+    def action_cancel(self) -> None:
+        """Cancel selection."""
+        self.post_message(self.ModelCancelled())
+
+    class ModelSelected(TextualMessage):
+        """Message sent when user selects a model."""
+
+        def __init__(self, model: str) -> None:
+            super().__init__()
+            self.model = model
+
+    class ModelCancelled(TextualMessage):
+        """Message sent when user cancels selection."""
+
+        pass

cli/widgets/conversation.py

@@ -0,0 +1,55 @@
+"""Conversation display widget for Kader CLI."""
+
+from textual.app import ComposeResult
+from textual.containers import 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:
+        super().__init__()
+        self.content = content
+        self.role = role
+        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}")
+
+
+class ConversationView(VerticalScroll):
+    """Scrollable conversation history with markdown rendering."""
+
+    DEFAULT_CSS = """
+    ConversationView {
+        padding: 1 2;
+    }
+
+    ConversationView Message {
+        margin-bottom: 1;
+        padding: 1;
+    }
+
+    ConversationView .message-user {
+        background: $surface;
+        border-left: thick $primary;
+    }
+
+    ConversationView .message-assistant {
+        background: $surface-darken-1;
+        border-left: thick $success;
+    }
+    """
+
+    def add_message(self, content: str, role: str = "user") -> None:
+        """Add a message to the conversation."""
+        message = Message(content, role)
+        self.mount(message)
+        self.scroll_end(animate=True)
+
+    def clear_messages(self) -> None:
+        """Clear all messages from the conversation."""
+        for child in self.query(Message):
+            child.remove()

cli/widgets/loading.py

@@ -0,0 +1,59 @@
+"""Loading spinner widget for Kader CLI."""
+
+from textual.reactive import reactive
+from textual.widgets import Static
+
+
+class LoadingSpinner(Static):
+    """Animated loading spinner shown during LLM response generation."""
+
+    DEFAULT_CSS = """
+    LoadingSpinner {
+        width: 100%;
+        height: auto;
+        padding: 1 2;
+        color: $text-muted;
+        text-style: italic;
+    }
+
+    LoadingSpinner.hidden {
+        display: none;
+    }
+    """
+
+    SPINNER_FRAMES = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"]
+
+    frame_index: reactive[int] = reactive(0)
+    is_spinning: reactive[bool] = reactive(False)
+
+    def __init__(self) -> None:
+        super().__init__()
+        self.add_class("hidden")
+        self._timer = None
+
+    def on_mount(self) -> None:
+        """Start the animation timer when mounted."""
+        self._timer = self.set_interval(0.1, self._advance_frame)
+
+    def _advance_frame(self) -> None:
+        """Advance to the next spinner frame."""
+        if self.is_spinning:
+            self.frame_index = (self.frame_index + 1) % len(self.SPINNER_FRAMES)
+
+    def watch_frame_index(self, frame_index: int) -> None:
+        """Update display when frame changes."""
+        if self.is_spinning:
+            spinner = self.SPINNER_FRAMES[frame_index]
+            self.update(f"{spinner} Kader is thinking...")
+
+    def start(self) -> None:
+        """Start the loading animation."""
+        self.is_spinning = True
+        self.remove_class("hidden")
+        self.frame_index = 0
+
+    def stop(self) -> None:
+        """Stop the loading animation."""
+        self.is_spinning = False
+        self.add_class("hidden")
+        self.update("")

kader/__init__.py

@@ -0,0 +1,22 @@
+"""
+Main Kader module initialization.
+
+This module sets up the required configuration when imported, including
+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
+
+# Initialize the configuration when the module is imported
+initialize_kader_config()
+
+__version__ = "0.1.0"
+__author__ = "Kader Project"
+__all__ = [
+    "KADER_DIR",
+    "ENV_FILE_PATH",
+    "initialize_kader_config",
+    # Export everything from providers and tools
+]

kader/agent/__init__.py

@@ -0,0 +1,8 @@
+"""
+Kader Agent module.
+"""
+
+from .agents import PlanningAgent, ReActAgent
+from .base import BaseAgent
+
+__all__ = ["BaseAgent", "ReActAgent", "PlanningAgent"]

kader/agent/agents.py

@@ -0,0 +1,126 @@
+"""
+Specific Agent Implementations.
+"""
+
+from typing import Optional, Union
+
+from kader.agent.base import BaseAgent
+from kader.memory import ConversationManager
+from kader.prompts import PlanningAgentPrompt, PromptBase, ReActAgentPrompt
+from kader.providers.base import BaseLLMProvider
+from kader.tools import BaseTool, TodoTool, ToolRegistry
+
+
+class ReActAgent(BaseAgent):
+    """
+    ReAct (Reasoning and Acting) Agent.
+
+    Uses a ReAct prompt strategy to reason about tasks and use tools.
+    """
+
+    def __init__(
+        self,
+        name: str,
+        tools: Union[list[BaseTool], ToolRegistry],
+        system_prompt: Optional[Union[str, PromptBase]] = None,
+        provider: Optional[BaseLLMProvider] = None,
+        memory: Optional[ConversationManager] = None,
+        retry_attempts: int = 3,
+        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,
+    ) -> None:
+        # Resolve tools for prompt context if necessary
+        # The base agent handles tool registration, but for the prompt template
+        # we might need to pass tool descriptions initially.
+
+        # Temporary logic to get tool names/descriptions for the prompt
+        # In a real scenario, this might need dynamic updates or be handled by the Prompt class itself
+        # accessing the agent's registry. Here we do a best-effort pre-fill.
+
+        _tools_list = []
+        if isinstance(tools, list):
+            _tools_list = tools
+        elif isinstance(tools, ToolRegistry):
+            _tools_list = tools.tools
+
+        tool_names = ", ".join([t.name for t in _tools_list])
+
+        if system_prompt is None:
+            system_prompt = ReActAgentPrompt(
+                tools=_tools_list,
+                tool_names=tool_names,
+                input="",  # This acts as a placeholder or initial context
+            )
+
+        super().__init__(
+            name=name,
+            system_prompt=system_prompt,
+            tools=tools,
+            provider=provider,
+            memory=memory,
+            retry_attempts=retry_attempts,
+            model_name=model_name,
+            session_id=session_id,
+            use_persistence=use_persistence,
+            interrupt_before_tool=interrupt_before_tool,
+            tool_confirmation_callback=tool_confirmation_callback,
+        )
+
+
+class PlanningAgent(BaseAgent):
+    """
+    Planning Agent.
+
+    Breaks tasks into plans and executes them.
+    """
+
+    def __init__(
+        self,
+        name: str,
+        tools: Union[list[BaseTool], ToolRegistry],
+        system_prompt: Optional[Union[str, PromptBase]] = None,
+        provider: Optional[BaseLLMProvider] = None,
+        memory: Optional[ConversationManager] = None,
+        retry_attempts: int = 3,
+        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,
+    ) -> None:
+        # Ensure TodoTool is available
+        _todo_tool = TodoTool()
+        if isinstance(tools, ToolRegistry):
+            if _todo_tool.name not in tools:
+                tools.register(_todo_tool)
+        elif isinstance(tools, list):
+            if not any(t.name == _todo_tool.name for t in tools):
+                tools.append(_todo_tool)
+
+        _tools_list = []
+        if isinstance(tools, list):
+            _tools_list = tools
+        elif isinstance(tools, ToolRegistry):
+            _tools_list = tools.tools
+
+        if system_prompt is None:
+            system_prompt = PlanningAgentPrompt(
+                tools=_tools_list, input="", agent_scratchpad=""
+            )
+
+        super().__init__(
+            name=name,
+            system_prompt=system_prompt,
+            tools=tools,
+            provider=provider,
+            memory=memory,
+            retry_attempts=retry_attempts,
+            model_name=model_name,
+            session_id=session_id,
+            use_persistence=use_persistence,
+            interrupt_before_tool=interrupt_before_tool,
+            tool_confirmation_callback=tool_confirmation_callback,
+        )