kader 2.7.0__tar.gz → 2.7.2__tar.gz

kader-2.7.2/.github/workflows/pages.yml

@@ -0,0 +1,58 @@
+name: Deploy Documentation
+
+on:
+  push:
+    branches:
+      - main
+  workflow_dispatch:
+
+permissions:
+  contents: read
+  pages: write
+  id-token: write
+
+concurrency:
+  group: "pages"
+  cancel-in-progress: false
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    
+    steps:
+      - name: Checkout Repository
+        uses: actions/checkout@v4
+
+      - name: Setup Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: '3.x'
+
+      - name: Install uv
+        run: |
+          pip install uv
+
+      - name: Install Dependencies
+        run: |
+          uv sync --group docs
+
+      - name: Build with MkDocs
+        run: |
+          uv run mkdocs build --verbose
+
+      - name: Upload Artifact
+        uses: actions/upload-pages-artifact@v3
+        with:
+          path: './site'
+
+  deploy:
+    environment:
+      name: github-pages
+      url: ${{ steps.deployment.outputs.page_url }}
+    runs-on: ubuntu-latest
+    needs: build
+    
+    steps:
+      - name: Deploy to GitHub Pages
+        id: deployment
+        uses: actions/deploy-pages@v4

{kader-2.7.0 → kader-2.7.2}/.gitignore

@@ -19,4 +19,7 @@ wheels/
 .env
 
 # optimization
-optimizers/
+optimizers/
+
+# MkDocs output
+site/

{kader-2.7.0 → kader-2.7.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kader
-Version: 2.7.0
+Version: 2.7.2
 Summary: kader coding agent
 License-File: LICENSE
 Requires-Python: >=3.11
@@ -17,6 +17,7 @@ Requires-Dist: openai>=2.20.0
 Requires-Dist: outdated>=0.2.2
 Requires-Dist: prompt-toolkit>=3.0.50
 Requires-Dist: python-frontmatter>=1.1.0
+Requires-Dist: pywinpty>=3.0.0; platform_system == 'Windows'
 Requires-Dist: pyyaml>=6.0.3
 Requires-Dist: rich>=14.0.0
 Requires-Dist: tenacity>=9.1.2

{kader-2.7.0 → kader-2.7.2}/cli/app.py

@@ -7,7 +7,6 @@ beautiful terminal output and prompt_toolkit for async input handling.
 import asyncio
 import atexit
 import json
-import subprocess
 import threading
 import warnings
 from concurrent.futures import ThreadPoolExecutor
@@ -122,6 +121,11 @@ class KaderApp:
 
     def _create_workflow(self, model_name: str) -> PlannerExecutorWorkflow:
         """Create a new PlannerExecutorWorkflow with the specified model."""
+        from kader.tools.exec_commands import CommandExecutorTool
+
+        CommandExecutorTool.set_output_callback(self._command_output_callback)
+        CommandExecutorTool.set_input_callback(self._command_input_callback)
+
         provider = LLMProviderFactory.create_provider(model_name)
 
         workflow = PlannerExecutorWorkflow(
@@ -249,35 +253,32 @@ class KaderApp:
                         format_plan_display(items)
                 except (json.JSONDecodeError, TypeError):
                     pass
-            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 _command_output_callback(self, output: str) -> None:
+        """Callback for streaming command output - called from agent thread."""
+        self.console.print(output, end="")
+
+    def _command_input_callback(self) -> str | None:
+        """Callback for getting user input during command execution."""
+        self._stop_spinner()
+        self.console.print()
+        self.console.print(
+            r"[kader.yellow]\[?] Command needs input:[/kader.yellow] ",
+            end="",
+        )
+        try:
+            user_input = input().strip()
+        except (EOFError, KeyboardInterrupt):
+            user_input = None
+        self._start_spinner()
+        return user_input
+
     def _tool_confirmation_callback(self, message: str) -> tuple[bool, Optional[str]]:
         """Callback for tool confirmation - called from agent thread.
 
@@ -611,37 +612,153 @@ class KaderApp:
         self.console.print(f"\n  [kader.orange]\\[>] Executing:[/kader.orange] `{cmd}`")
 
         try:
-            process = await asyncio.create_subprocess_shell(
-                cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE
-            )
-            stdout, stderr = await process.communicate()
-
-            output = ""
-            if stdout:
-                output += stdout.decode().strip()
-            if stderr:
-                if output:
-                    output += "\n\n"
-                output += f"Stderr:\n{stderr.decode().strip()}"
+            output = await self._run_terminal_command_pty(cmd)
 
             if not output:
-                output = "Command executed successfully with no output."
-
-            self.console.print()
-            self.console.print(
-                Panel(
-                    output,
-                    title="[kader.orange]Terminal Output[/kader.orange]",
-                    border_style="dark_orange",
-                    padding=(0, 1),
+                self.console.print(
+                    "  [dim]Command executed successfully with no output.[/dim]"
                 )
-            )
 
         except Exception as e:
             self.console.print(
                 rf"  [kader.red]\[-][/kader.red] Error executing command: {e}"
             )
 
+    async def _run_terminal_command_pty(self, command: str) -> str:
+        """Run a terminal command using PTY for interactive support."""
+        import platform
+
+        system = platform.system().lower()
+
+        if system == "windows":
+            return await self._run_terminal_command_winpty(command)
+        else:
+            return await self._run_terminal_command_unix_pty(command)
+
+    async def _run_terminal_command_unix_pty(self, command: str) -> str:
+        """Run a terminal command using PTY on Unix."""
+        import os
+        import pty
+
+        master_fd, slave_fd = pty.openpty()
+
+        env = os.environ.copy()
+        env["TERM"] = "xterm-256color"
+
+        shell = "/bin/bash"
+
+        try:
+            process = await asyncio.create_subprocess_exec(
+                shell,
+                "-c",
+                command,
+                stdin=slave_fd,
+                stdout=asyncio.subprocess.PIPE,
+                stderr=asyncio.subprocess.STDOUT,
+                env=env,
+            )
+        finally:
+            os.close(slave_fd)
+            os.close(master_fd)
+
+        output_parts = []
+        stdout = process.stdout
+        assert stdout is not None
+
+        while True:
+            line = await asyncio.wait_for(stdout.readline(), timeout=0.1)
+            if line:
+                text = line.decode("utf-8", errors="replace")
+                output_parts.append(text)
+                self.console.print(text, end="")
+            elif process.returncode is not None:
+                break
+
+        await process.wait()
+        return "".join(output_parts).strip()
+
+    async def _run_terminal_command_winpty(self, command: str) -> str:
+        """Run a terminal command using pywinpty on Windows."""
+
+        try:
+            import pywinpty
+        except ImportError:
+            return await self._run_terminal_command_direct(command)
+
+        command_lower = command.lower().strip()
+        is_powershell = command_lower.startswith("pwsh") or command_lower.startswith(
+            "powershell"
+        )
+
+        if is_powershell:
+            shell = "powershell.exe"
+            shell_args = ["-Command", command]
+        else:
+            shell = "cmd.exe"
+            shell_args = ["/c", command]
+
+        try:
+            pty_obj = pywinpty.PTY(width=80, height=24, visible=False)
+        except Exception:
+            return await self._run_terminal_command_direct(command)
+
+        try:
+            process = pty_obj.spawn(shell, shell_args)
+        except Exception:
+            return await self._run_terminal_command_direct(command)
+
+        output_parts = []
+        max_attempts = 100
+        attempts = 0
+
+        while attempts < max_attempts:
+            try:
+                data = process.read(blocking=False)
+                if data:
+                    output_parts.append(data)
+                    self.console.print(data, end="")
+                    attempts = 0
+            except Exception:
+                pass
+
+            if not process.isalive():
+                await asyncio.sleep(0.1)
+                try:
+                    data = process.read(blocking=False)
+                    if data:
+                        output_parts.append(data)
+                        self.console.print(data, end="")
+                except Exception:
+                    pass
+                if not process.isalive():
+                    break
+
+            attempts += 1
+            await asyncio.sleep(0.05)
+
+        result = "".join(output_parts).strip()
+
+        if not result:
+            return await self._run_terminal_command_direct(command)
+
+        return result
+
+    async def _run_terminal_command_direct(self, command: str) -> str:
+        """Run a terminal command directly without PTY (fallback)."""
+
+        try:
+            process = await asyncio.create_subprocess_shell(
+                command,
+                stdout=asyncio.subprocess.PIPE,
+                stderr=asyncio.subprocess.STDOUT,
+            )
+            stdout, _ = await process.communicate()
+
+            output = stdout.decode("utf-8", errors="replace").strip()
+            return output
+        except Exception as e:
+            return f"Error: {str(e)}"
+
     def _handle_save_session(self) -> None:
         """Save the current session."""
         import shutil
@@ -1058,12 +1175,15 @@ class KaderApp:
 
     def run(self) -> None:
         """Run the Kader CLI application."""
+        from kader.tools.exec_commands import CommandExecutorTool
+
         try:
             asyncio.run(self._run_async())
         except KeyboardInterrupt:
             self.console.print("\n  [kader.muted]Goodbye! 👋[/kader.muted]")
         finally:
             self._stop_spinner()
+            CommandExecutorTool.clear_callbacks()
 
 
 def main() -> None:

kader-2.7.2/docs/cli/index.md

@@ -0,0 +1,183 @@
+# CLI Reference
+
+![Kader CLI](../assets/imgs/kader-cli.png)
+
+The Kader CLI is an interactive terminal-based AI coding assistant built with Rich and prompt_toolkit.
+
+## Features
+
+- **Planner-Executor Workflow** — Intelligent agent with reasoning, planning, and tool execution
+- **Built-in Tools** — File system, command execution, web search
+- **Rich Conversation** — Beautiful markdown-rendered chat with styled panels
+- **Session Persistence** — Save and load conversation sessions
+- **Tool Confirmation** — Interactive approval for tool execution
+- **Model Selection** — Dynamic model switching interface
+- **Multi-Provider Support** — Ollama, Google Gemini, Anthropic, Mistral, OpenAI, and more
+
+## Running the CLI
+
+```bash
+# Using uv tool (recommended - installs globally)
+kader
+
+# Or using uv run
+uv run python -m cli
+
+# Or clone and run
+git clone https://github.com/Kader-AI-hub/kader.git
+cd kader
+uv run python -m cli
+```
+
+## Commands
+
+| Command | Description |
+|---------|-------------|
+| `/help` | Show command reference |
+| `/models` | Show and switch available models |
+| `/clear` | Clear conversation |
+| `/save` | Save current session |
+| `/load <id>` | Load a saved session |
+| `/sessions` | List saved sessions |
+| `/skills` | List loaded skills |
+| `/commands` | List special commands |
+| `/cost` | Show usage costs |
+| `/init` | Initialize .kader directory with KADER.md |
+| `/exit` | Exit the CLI |
+| `!cmd` | Run terminal command |
+
+## Keyboard Shortcuts
+
+| Shortcut | Action |
+|----------|--------|
+| `Ctrl+C` | Cancel current operation |
+| `Ctrl+D` | Exit the CLI |
+
+## Session Management
+
+Sessions are saved to `~/.kader/sessions/`. Use:
+
+- `/save` — Save current conversation
+- `/sessions` — List all saved sessions
+- `/load <session_id>` — Restore a session
+
+## Tool Confirmation System
+
+Kader includes an interactive tool confirmation system that prompts for approval before executing tools:
+
+- Safe execution of potentially destructive operations
+- Simple `[Y/n/reason]` prompt for quick approval
+- Ability to provide context when rejecting a tool
+
+## Skills System
+
+Skills are loaded from:
+
+- `~/.kader/skills/` — User-level skills
+- `./.kader/skills/` — Project-level skills
+
+Use `/skills` to list all available skills.
+
+### Skill File Format
+
+```yaml
+---
+name: python-expert
+description: Expert in Python programming and best practices
+---
+
+# Python Expert Skill
+
+You are an expert Python developer...
+```
+
+## Special Commands
+
+Commands are loaded from:
+
+- `./.kader/commands/` — Project-level commands (higher priority)
+- `~/.kader/commands/` — User-level commands
+
+Use `/commands` to list all available special commands.
+
+### Creating a Command
+
+Create a command directory with a `CONTENT.md` file:
+
+```bash
+mkdir -p ~/.kader/commands/mycommand
+```
+
+**CONTENT.md format:**
+
+```yaml
+---
+description: What this command does
+---
+
+# Command Instructions
+
+Your command agent instructions here...
+```
+
+### Using Commands
+
+```
+/mycommand
+/mycommand do something specific
+```
+
+### Example: Lint and Test Command
+
+```yaml
+---
+description: Lint and test the codebase following AGENTS.md
+---
+
+You are a Lint and Test Agent specialized in maintaining code quality.
+
+## Instructions
+
+1. Run: uv run ruff check .
+2. Run: uv run ruff format --check .
+3. Run: uv run pytest -v
+4. Report results
+```
+
+Usage: `/lint-test` or `/lint-test run full check`
+
+## Model Selection
+
+The model selection interface allows you to:
+
+- Browse all available models from configured providers
+- Switch models on the fly during conversation
+- See which model is currently active
+
+### Supported Providers
+
+| Provider | Format | Example |
+|----------|--------|---------|
+| Ollama | `ollama:model` | `ollama:llama3` |
+| Google Gemini | `google:model` | `google:gemini-2.5-flash` |
+| Mistral | `mistral:model` | `mistral:small-3.1` |
+| Anthropic | `anthropic:model` | `anthropic:claude-3.5-sonnet` |
+| OpenAI | `openai:model` | `openai:gpt-4o` |
+| Moonshot | `moonshot:model` | `moonshot:kimi-k2.5` |
+| Z.ai | `zai:model` | `zai:glm-5` |
+| OpenRouter | `openrouter:model` | `openrouter:anthropic/claude-3.5-sonnet` |
+| OpenCode | `opencode:model` | `opencode:claude-3.5-sonnet` |
+| Groq | `groq:model` | `groq:llama-3.3-70b-versatile` |
+
+### Setting API Keys
+
+```bash
+export GOOGLE_API_KEY="your-google-api-key"
+export ANTHROPIC_API_KEY="your-anthropic-api-key"
+export MISTRAL_API_KEY="your-mistral-api-key"
+export OPENAI_API_KEY="your-openai-api-key"
+export MOONSHOT_API_KEY="your-kimi-api-key"
+export ZAI_API_KEY="your-glm-api-key"
+export OPENROUTER_API_KEY="your-openrouter-api-key"
+export GROQ_API_KEY="your-groq-api-key"
+```

kader-2.7.2/docs/configuration.md

@@ -0,0 +1,107 @@
+# Configuration
+
+Kader can be configured through environment variables, YAML files, and the `.kader` directory in your home folder.
+
+## Environment Variables
+
+| Variable | Description | Required |
+|----------|-------------|----------|
+| `KADER_DIR` | Kader config directory (default: `~/.kader`) | No |
+| `GEMINI_API_KEY` | Google Gemini API key | For Google Provider |
+| `MISTRAL_API_KEY` | Mistral API key | For Mistral Provider |
+| `ANTHROPIC_API_KEY` | Anthropic API key | For Anthropic Provider |
+| `OPENAI_API_KEY` | OpenAI API key | For OpenAI Provider |
+| `MOONSHOT_API_KEY` | Moonshot AI key | For Moonshot Provider |
+| `ZAI_API_KEY` | Z.ai (GLM) API key | For Z.ai Provider |
+| `OPENROUTER_API_KEY` | OpenRouter key | For OpenRouter Provider |
+| `OPENCODE_API_KEY` | OpenCode API key | For OpenCode Provider |
+| `GROQ_API_KEY` | Groq API key | For Groq Provider |
+
+## .kader Directory
+
+When the kader module is imported for the first time, it automatically creates a `.kader` directory in your home directory:
+
+```
+~/.kader/
+├── .env                   # Environment variables
+├── memory/               # Memory and session storage
+│   └── sessions/         # Saved conversation sessions
+├── skills/               # User-level skills
+├── commands/             # User-level special commands
+└── KADER.md              # Agent instructions file
+```
+
+## YAML Agent Configuration
+
+BaseAgent supports loading configuration from YAML files:
+
+```yaml
+# agent.yaml
+name: ConfiguredAgent
+system_prompt: "You are a helpful coding assistant."
+tools:
+  - read_file
+  - write_file
+  - todo_tool
+provider:
+  model: llama3.2
+  provider: ollama
+persistence: true
+retry_attempts: 3
+interrupt_before_tool: true
+```
+
+```python
+agent = BaseAgent.from_yaml("agent.yaml")
+```
+
+## Provider Configuration Format
+
+### Ollama
+
+```yaml
+provider:
+  provider: ollama
+  model: llama3.2
+  base_url: "http://localhost:11434"
+  timeout: 120
+```
+
+### Google Gemini
+
+```yaml
+provider:
+  provider: google
+  model: gemini-2.0-flash
+  temperature: 0.7
+  max_tokens: 2048
+```
+
+### Anthropic
+
+```yaml
+provider:
+  provider: anthropic
+  model: claude-3-5-sonnet-20241022
+  temperature: 0.7
+```
+
+### OpenAI-Compatible
+
+```yaml
+provider:
+  provider: openai
+  model: gpt-4o
+  base_url: "https://api.openai.com/v1"
+  api_key: "your-openai-key"
+```
+
+For Groq, OpenRouter, etc., use the appropriate `base_url`.
+
+## Session Storage
+
+Sessions are saved to `~/.kader/memory/sessions/` and include:
+- Conversation history
+- Agent state
+- Tool execution logs
+- Sub-agent contexts (for aggregated context)