kader 2.6.2__tar.gz → 2.6.4__tar.gz

{kader-2.6.2 → kader-2.6.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kader
-Version: 2.6.2
+Version: 2.6.4
 Summary: kader coding agent
 License-File: LICENSE
 Requires-Python: >=3.11
@@ -69,6 +69,18 @@ uv sync
 uv run python -m cli
 ```
 
+### Using uv tool
+
+With uv tool, you can install Kader globally and run it directly with the `kader` command:
+
+```bash
+# Install Kader globally using uv tool
+uv tool install kader
+
+# Run the CLI
+kader
+```
+
 ### Using pip
 
 ```bash

{kader-2.6.2 → kader-2.6.4}/README.md

@@ -43,6 +43,18 @@ uv sync
 uv run python -m cli
 ```
 
+### Using uv tool
+
+With uv tool, you can install Kader globally and run it directly with the `kader` command:
+
+```bash
+# Install Kader globally using uv tool
+uv tool install kader
+
+# Run the CLI
+kader
+```
+
 ### Using pip
 
 ```bash

{kader-2.6.2 → kader-2.6.4}/cli/app.py

@@ -133,11 +133,33 @@ class KaderApp:
             self.console.print(
                 rf"  [kader.green]\[+] {tool_name}[/kader.green] completed successfully"
             )
+            if tool_name == "execute_command" and ":\n" in result:
+                output = result.split(":\n", 1)[1]
+                self.console.print()
+                self.console.print(
+                    Panel(
+                        output.strip(),
+                        title="[kader.orange]Command Output[/kader.orange]",
+                        border_style="dark_orange",
+                        padding=(0, 1),
+                    )
+                )
         else:
             error_preview = result[:100] + "..." if len(result) > 100 else result
             self.console.print(
                 rf"  [kader.red]\[-] {tool_name}[/kader.red] failed: {error_preview}"
             )
+            if tool_name == "execute_command" and ":\n" in result:
+                output = result.split(":\n", 1)[1]
+                self.console.print()
+                self.console.print(
+                    Panel(
+                        output.strip(),
+                        title="[kader.red]Command Output/Error[/kader.red]",
+                        border_style="red",
+                        padding=(0, 1),
+                    )
+                )
         self._start_spinner()
 
     def _tool_confirmation_callback(self, message: str) -> tuple[bool, Optional[str]]:

{kader-2.6.2 → kader-2.6.4}/kader/tools/exec_commands.py

@@ -173,9 +173,87 @@ class CommandExecutorTool(BaseTool[str]):
 
         return True, ""
 
+    def _stream_command_output(self, command: str, timeout: int) -> tuple[int, str]:
+        """
+        Streams the output of a shell command and collects it.
+
+        Args:
+            command: The command to execute
+            timeout: Timeout in seconds
+
+        Returns:
+            Tuple of (return_code, captured_output)
+        """
+        import time
+        from queue import Empty, Queue
+        from threading import Thread
+
+        # Prepare kwargs for Popen based on OS
+        kwargs = {
+            "stdout": subprocess.PIPE,
+            "stderr": subprocess.STDOUT,
+            "text": True,
+            "shell": True,
+        }
+
+        if self._host_os != "windows":
+            kwargs["executable"] = self._shell
+
+        process = subprocess.Popen(command, **kwargs)
+        captured_output = []
+
+        # Use a queue to capture output asynchronously for timeout handling
+        q = Queue()
+
+        def enqueue_output(out, queue):
+            for line in out:
+                queue.put(line)
+            try:
+                out.close()
+            except AttributeError:
+                pass  # mock lists in tests might not have close()
+
+        t = Thread(target=enqueue_output, args=(process.stdout, q))
+        t.daemon = True
+        t.start()
+
+        start_time = time.time()
+
+        while True:
+            # Check for timeout
+            if timeout > 0 and time.time() - start_time > timeout:
+                process.terminate()
+                try:
+                    process.wait(timeout=1)
+                except subprocess.TimeoutExpired:
+                    process.kill()
+                raise subprocess.TimeoutExpired(
+                    command, timeout, "".join(captured_output).encode()
+                )
+
+            try:
+                # Read line with a short timeout to allow checking overall execution timeout
+                line = q.get(timeout=0.1)
+
+                # Collect output
+                captured_output.append(line)
+            except Empty:
+                # Queue is empty, check if process indicates it's done
+                # Note: t.is_alive() is checked because poll() might return before stdout is fully read
+                if process.poll() is not None and not t.is_alive():
+                    break
+
+        # Ensure thread finished
+        t.join(timeout=1)
+
+        # Ensure process finished
+        process.wait()
+
+        return process.returncode, "".join(captured_output).strip()
+
     def execute(self, command: str, timeout: int = 30) -> str:
         """
-        Execute a command on the host system.
+        Execute a command on the host system and stream its output.
 
         Args:
             command: The command to execute
@@ -190,39 +268,19 @@ class CommandExecutorTool(BaseTool[str]):
             if not is_valid:
                 return f"Validation Error: {reason}"
 
-            # Execute the command
-            if self._host_os == "windows":
-                # On Windows, use shell=True to allow for more complex commands
-                result = subprocess.run(
-                    command, shell=True, capture_output=True, text=True, timeout=timeout
-                )
-            else:
-                # On Unix-like systems, use the appropriate shell
-                result = subprocess.run(
-                    command,
-                    shell=True,  # Using shell=True to handle pipes and redirections
-                    capture_output=True,
-                    text=True,
-                    timeout=timeout,
-                    executable=self._shell,
-                )
+            # Execute and stream the command output
+            returncode, output = self._stream_command_output(command, timeout)
 
             # Format result as a string
-            if result.returncode == 0:
-                output = result.stdout.strip()
+            if returncode == 0:
                 if output:
                     return f"Command executed successfully:\n{output}"
                 else:
                     return "Command executed successfully (no output)"
             else:
-                stdout = result.stdout.strip()
-                stderr = result.stderr.strip()
-
-                output_parts = [f"Command failed with exit code {result.returncode}"]
-                if stdout:
-                    output_parts.append(stdout)
-                if stderr:
-                    output_parts.append(stderr)
+                output_parts = [f"Command failed with exit code {returncode}"]
+                if output:
+                    output_parts.append(output)
 
                 return (
                     ":\n".join(output_parts)

{kader-2.6.2 → kader-2.6.4}/kader/workflows/planner_executor.py

@@ -17,6 +17,7 @@ from kader.memory.types import get_default_memory_dir
 from kader.prompts import KaderPlannerPrompt
 from kader.providers.base import BaseLLMProvider, Message
 from kader.tools import AgentTool, TodoTool, ToolRegistry
+from kader.tools.filesys import GlobTool, GrepTool, ReadDirectoryTool, ReadFileTool
 from kader.utils import Checkpointer
 
 from .base import BaseWorkflow
@@ -115,12 +116,18 @@ class PlannerExecutorWorkflow(BaseWorkflow):
         return None
 
     def _build_planner(self) -> PlanningAgent:
-        """Build the PlanningAgent with TodoTool and AgentTool(s)."""
+        """Build the PlanningAgent with TodoTool, file system tools, and AgentTool(s)."""
         registry = ToolRegistry()
 
         # TodoTool is added implicitly by PlanningAgent, but we ensure it's there
         registry.register(TodoTool())
 
+        # Add reading and file system search tools
+        registry.register(ReadFileTool())
+        registry.register(ReadDirectoryTool())
+        registry.register(GlobTool())
+        registry.register(GrepTool())
+
         # Add AgentTool(s) for sub-task delegation
         for executor_name in self.executor_names:
             agent_tool = AgentTool(

{kader-2.6.2 → kader-2.6.4}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "kader"
-version = "2.6.2"
+version = "2.6.4"
 description = "kader coding agent"
 readme = "README.md"
 requires-python = ">=3.11"

{kader-2.6.2 → kader-2.6.4}/tests/tools/test_exec_commands.py

@@ -108,27 +108,27 @@ class TestCommandExecutorTool:
             assert "Empty command" in reason
 
     @patch("platform.system")
-    @patch("subprocess.run")
-    def test_execute_success(self, mock_subprocess_run, mock_platform_system):
+    @patch("subprocess.Popen")
+    def test_execute_success(self, mock_subprocess_popen, mock_platform_system):
         """Test successful command execution."""
         # Mock platform and subprocess
         mock_platform_system.return_value = "Linux"
-        mock_result = Mock()
-        mock_result.returncode = 0
-        mock_result.stdout = "Command output"
-        mock_result.stderr = ""
-        mock_subprocess_run.return_value = mock_result
+        mock_process = Mock()
+        mock_process.returncode = 0
+        mock_process.stdout = ["Command output\n"]
+        mock_process.poll.return_value = 0
+        mock_subprocess_popen.return_value = mock_process
 
         tool = CommandExecutorTool()
         result = tool.execute("echo hello", timeout=10)
 
         # Verify subprocess was called correctly
-        mock_subprocess_run.assert_called_once_with(
+        mock_subprocess_popen.assert_called_once_with(
             "echo hello",
-            shell=True,
-            capture_output=True,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.STDOUT,
             text=True,
-            timeout=10,
+            shell=True,
             executable="/bin/bash",
         )
 
@@ -137,27 +137,27 @@ class TestCommandExecutorTool:
         assert "Command output" in result
 
     @patch("platform.system")
-    @patch("subprocess.run")
-    def test_execute_success_windows(self, mock_subprocess_run, mock_platform_system):
+    @patch("subprocess.Popen")
+    def test_execute_success_windows(self, mock_subprocess_popen, mock_platform_system):
         """Test successful command execution on Windows."""
         # Mock platform and subprocess
         mock_platform_system.return_value = "Windows"
-        mock_result = Mock()
-        mock_result.returncode = 0
-        mock_result.stdout = "Windows output"
-        mock_result.stderr = ""
-        mock_subprocess_run.return_value = mock_result
+        mock_process = Mock()
+        mock_process.returncode = 0
+        mock_process.stdout = ["Windows output\n"]
+        mock_process.poll.return_value = 0
+        mock_subprocess_popen.return_value = mock_process
 
         tool = CommandExecutorTool()
         result = tool.execute("echo hello")
 
         # Verify subprocess was called correctly for Windows
-        mock_subprocess_run.assert_called_once_with(
+        mock_subprocess_popen.assert_called_once_with(
             "echo hello",
-            shell=True,
-            capture_output=True,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.STDOUT,
             text=True,
-            timeout=30,  # Default timeout
+            shell=True,
         )
 
         # Verify the result
@@ -165,16 +165,16 @@ class TestCommandExecutorTool:
         assert "Windows output" in result
 
     @patch("platform.system")
-    @patch("subprocess.run")
-    def test_execute_command_failed(self, mock_subprocess_run, mock_platform_system):
+    @patch("subprocess.Popen")
+    def test_execute_command_failed(self, mock_subprocess_popen, mock_platform_system):
         """Test command execution that fails."""
         # Mock platform and subprocess
         mock_platform_system.return_value = "Linux"
-        mock_result = Mock()
-        mock_result.returncode = 1
-        mock_result.stdout = ""
-        mock_result.stderr = "Command failed"
-        mock_subprocess_run.return_value = mock_result
+        mock_process = Mock()
+        mock_process.returncode = 1
+        mock_process.stdout = ["Command failed\n"]
+        mock_process.poll.return_value = 1
+        mock_subprocess_popen.return_value = mock_process
 
         tool = CommandExecutorTool()
         result = tool.execute("invalid_command")
@@ -184,38 +184,40 @@ class TestCommandExecutorTool:
         assert "Command failed" in result
 
     @patch("platform.system")
-    @patch("subprocess.run")
+    @patch("subprocess.Popen")
     def test_execute_command_failed_with_output(
-        self, mock_subprocess_run, mock_platform_system
+        self, mock_subprocess_popen, mock_platform_system
     ):
         """Test command execution that fails but has stdout."""
         # Mock platform and subprocess
         mock_platform_system.return_value = "Linux"
-        mock_result = Mock()
-        mock_result.returncode = 2
-        mock_result.stdout = "Partial output"
-        mock_result.stderr = "Error message"
-        mock_subprocess_run.return_value = mock_result
+        mock_process = Mock()
+        mock_process.returncode = 2
+        mock_process.stdout = ["Partial output\n", "Error message\n"]
+        mock_process.poll.return_value = 2
+        mock_subprocess_popen.return_value = mock_process
 
         tool = CommandExecutorTool()
         result = tool.execute("problematic_command")
 
-        # Verify the result includes both stdout and stderr
+        # Verify the result includes both stdout and stderr (which are merged in Popen)
         assert "Command failed with exit code 2" in result
         assert "Partial output" in result
         assert "Error message" in result
 
     @patch("platform.system")
-    @patch("subprocess.run")
-    def test_execute_command_no_output(self, mock_subprocess_run, mock_platform_system):
+    @patch("subprocess.Popen")
+    def test_execute_command_no_output(
+        self, mock_subprocess_popen, mock_platform_system
+    ):
         """Test command execution with no output."""
         # Mock platform and subprocess
         mock_platform_system.return_value = "Linux"
-        mock_result = Mock()
-        mock_result.returncode = 0
-        mock_result.stdout = ""
-        mock_result.stderr = ""
-        mock_subprocess_run.return_value = mock_result
+        mock_process = Mock()
+        mock_process.returncode = 0
+        mock_process.stdout = []
+        mock_process.poll.return_value = 0
+        mock_subprocess_popen.return_value = mock_process
 
         tool = CommandExecutorTool()
         result = tool.execute("no_output_command")
@@ -224,26 +226,36 @@ class TestCommandExecutorTool:
         assert "Command executed successfully (no output)" in result
 
     @patch("platform.system")
-    @patch("subprocess.run")
-    def test_execute_command_timeout(self, mock_subprocess_run, mock_platform_system):
+    @patch("subprocess.Popen")
+    def test_execute_command_timeout(self, mock_subprocess_popen, mock_platform_system):
         """Test command execution that times out."""
-        # Mock platform and subprocess to raise TimeoutExpired
+        # Mock platform and subprocess
         mock_platform_system.return_value = "Linux"
-        mock_subprocess_run.side_effect = subprocess.TimeoutExpired("command", 5)
-
-        tool = CommandExecutorTool()
-        result = tool.execute("slow_command", timeout=5)
+        mock_process = Mock()
+        mock_process.stdout = []
+        mock_process.poll.return_value = None  # Process is still running
+        mock_subprocess_popen.return_value = mock_process
+
+        # We need to simulate the slow process by making the real time pass faster or wait,
+        # but time.time() is used, so we need to patch time.time
+        with patch("time.time") as mock_time:
+            # First call is start time, second is in loop check
+            mock_time.side_effect = [100.0, 110.0]
+            tool = CommandExecutorTool()
+            result = tool.execute("slow_command", timeout=5)
 
         # Verify the result
         assert "Command timed out after 5 seconds" in result
 
     @patch("platform.system")
-    @patch("subprocess.run")
-    def test_execute_command_exception(self, mock_subprocess_run, mock_platform_system):
+    @patch("subprocess.Popen")
+    def test_execute_command_exception(
+        self, mock_subprocess_popen, mock_platform_system
+    ):
         """Test command execution that raises an exception."""
         # Mock platform and subprocess to raise a general exception
         mock_platform_system.return_value = "Linux"
-        mock_subprocess_run.side_effect = Exception("Unexpected error")
+        mock_subprocess_popen.side_effect = Exception("Unexpected error")
 
         tool = CommandExecutorTool()
         result = tool.execute("error_command")
@@ -252,9 +264,9 @@ class TestCommandExecutorTool:
         assert "Execution Error: Unexpected error" in result
 
     @patch("platform.system")
-    @patch("subprocess.run")
+    @patch("subprocess.Popen")
     def test_execute_invalid_command_windows(
-        self, mock_subprocess_run, mock_platform_system
+        self, mock_subprocess_popen, mock_platform_system
     ):
         """Test executing an invalid command on Windows."""
         mock_platform_system.return_value = "Windows"
@@ -267,13 +279,13 @@ class TestCommandExecutorTool:
         assert "Unix/Linux command" in result
         assert "PowerShell" in result
 
-        # subprocess.run should not be called
-        mock_subprocess_run.assert_not_called()
+        # subprocess.Popen should not be called
+        mock_subprocess_popen.assert_not_called()
 
     @patch("platform.system")
-    @patch("subprocess.run")
+    @patch("subprocess.Popen")
     def test_execute_invalid_command_unix(
-        self, mock_subprocess_run, mock_platform_system
+        self, mock_subprocess_popen, mock_platform_system
     ):
         """Test executing an invalid command on Unix."""
         mock_platform_system.return_value = "Linux"
@@ -286,21 +298,21 @@ class TestCommandExecutorTool:
         assert "Windows command" in result
         assert "Unix equivalent" in result
 
-        # subprocess.run should not be called
-        mock_subprocess_run.assert_not_called()
+        # subprocess.Popen should not be called
+        mock_subprocess_popen.assert_not_called()
 
     @patch("platform.system")
-    @patch("subprocess.run")
+    @patch("subprocess.Popen")
     @pytest.mark.asyncio
-    async def test_aexecute(self, mock_subprocess_run, mock_platform_system):
+    async def test_aexecute(self, mock_subprocess_popen, mock_platform_system):
         """Test asynchronous command execution."""
         # Mock platform and subprocess
         mock_platform_system.return_value = "Linux"
-        mock_result = Mock()
-        mock_result.returncode = 0
-        mock_result.stdout = "Async output"
-        mock_result.stderr = ""
-        mock_subprocess_run.return_value = mock_result
+        mock_process = Mock()
+        mock_process.returncode = 0
+        mock_process.stdout = ["Async output\n"]
+        mock_process.poll.return_value = 0
+        mock_subprocess_popen.return_value = mock_process
 
         tool = CommandExecutorTool()
         result = await tool.aexecute("echo async", timeout=15)

{kader-2.6.2 → kader-2.6.4}/uv.lock

@@ -582,7 +582,7 @@ wheels = [
 
 [[package]]
 name = "kader"
-version = "2.6.2"
+version = "2.6.4"
 source = { editable = "." }
 dependencies = [
     { name = "aiofiles" },