kader 0.1.0__py3-none-any.whl

kader/tools/web.py

@@ -0,0 +1,246 @@
+"""
+Web Tools for Agentic Operations.
+
+Provides web search and fetch capabilities using Ollama's native API.
+"""
+
+import json
+from typing import Any
+
+from .base import (
+    BaseTool,
+    ParameterSchema,
+    ToolCategory,
+)
+
+try:
+    import ollama
+except ImportError:
+    ollama = None
+
+
+class WebSearchTool(BaseTool[list[dict[str, Any]]]):
+    """
+    Tool to search the web using Ollama's search capability.
+    """
+
+    def __init__(self) -> None:
+        """Initialize the web search tool."""
+        super().__init__(
+            name="web_search",
+            description=(
+                "Search the web for information. Returns a list of relevant "
+                "results with titles, descriptions, and URLs."
+            ),
+            parameters=[
+                ParameterSchema(
+                    name="query",
+                    type="string",
+                    description="Search query",
+                ),
+                ParameterSchema(
+                    name="limit",
+                    type="integer",
+                    description="Number of results to return (max 10)",
+                    required=False,
+                    default=5,
+                    minimum=1,
+                    maximum=10,
+                ),
+            ],
+            category=ToolCategory.WEB,
+        )
+
+    def execute(self, query: str, limit: int = 5) -> list[dict[str, Any]]:
+        """
+        Execute web search.
+
+        Args:
+            query: Search query
+            limit: Number of results (default 5)
+
+        Returns:
+        """
+        if ollama is None:
+            raise ImportError(
+                "ollama is required for web tools. Install it with: uv add ollama"
+            )
+
+        try:
+            # Note: Ollama python lib uses 'limit' or just implicitly returns results
+            # The exact signature might vary as it's experimental, but based on docs:
+            # results = ollama.web_search(query=query)
+            # We'll try to slice manually if limit is not supported directly
+
+            # Using getattr to avoid static analysis errors if method is missing in older stub
+            search_func = getattr(ollama, "web_search", None)
+
+            if not search_func:
+                # Fallback or error if not available
+                # Assuming duckduckgo-search as fallback if allowed, but plan said Ollama first
+                # Let's check if we can import duckduckgo search as a robust fallback
+                # since "ollama.web_search" might be a hosted-only feature in some contexts.
+                # But per instruction, we use Ollama.
+
+                # If function is missing, raise clear error
+                raise NotImplementedError(
+                    "ollama.web_search is not available in the installed library version. "
+                    "Ensure 'ollama>=0.6.0' is installed."
+                )
+
+            # Execute search
+            response = search_func(query=query)
+
+            # Parse results
+            # Response might be a dict, an object with .results, or a list
+            results = []
+
+            if isinstance(response, dict):
+                results = response.get("results", [])
+            elif hasattr(response, "results"):
+                results = response.results
+            elif hasattr(response, "__dict__") and "results" in response.__dict__:
+                # Handle WebSearchResult object specifically
+                results = response.results
+            elif isinstance(response, list):
+                results = response
+            else:
+                # If it's some other object that behaves like a dict but failed above checks
+                try:
+                    results = response["results"]
+                except (TypeError, KeyError, AttributeError):
+                    # As a last resort, assume the response itself might be the iterable result
+                    results = response
+
+            # Type check results to ensure it's a list (or iterable)
+            if not isinstance(results, list):
+                # Try to convert to list if it's iterable
+                try:
+                    results = list(results)
+                except TypeError:
+                    # If not iterable, wrap it or return empty
+                    results = []
+
+            # Ensure results are JSON serializable
+            serializable_results = []
+            for item in results[:limit]:
+                if isinstance(item, (str, int, float, bool, type(None))):
+                    serializable_results.append(item)
+                elif isinstance(item, dict):
+                    # Ensure all dict values are serializable
+                    serializable_dict = {}
+                    for k, v in item.items():
+                        try:
+                            json.dumps(v)  # Test if serializable
+                            serializable_dict[k] = v
+                        except TypeError:
+                            serializable_dict[k] = str(
+                                v
+                            )  # Convert non-serializable to string
+                    serializable_results.append(serializable_dict)
+                else:
+                    # Convert any other type to string representation
+                    serializable_results.append(str(item))
+
+            return serializable_results
+
+        except NotImplementedError:
+            raise
+        except Exception as e:
+            # Handle specific Ollama errors
+            raise RuntimeError(f"Web search failed: {str(e)}")
+
+    async def aexecute(self, query: str, limit: int = 5) -> list[dict[str, Any]]:
+        """Async version of execute."""
+        import asyncio
+
+        return await asyncio.to_thread(self.execute, query, limit)
+
+    def get_interruption_message(self, query: str, **kwargs) -> str:
+        """Get interruption message for user confirmation."""
+        return f"execute web_search: {query}"
+
+
+class WebFetchTool(BaseTool[str]):
+    """
+    Tool to fetch and extract text content from a web page.
+    """
+
+    def __init__(self) -> None:
+        """Initialize the web fetch tool."""
+        super().__init__(
+            name="web_fetch",
+            description=(
+                "Fetch and extract readable text content from a URL. "
+                "Useful for reading documentation, articles, or web pages found via search."
+            ),
+            parameters=[
+                ParameterSchema(
+                    name="url",
+                    type="string",
+                    description="URL of the page to fetch",
+                ),
+            ],
+            category=ToolCategory.WEB,
+        )
+
+    def execute(self, url: str) -> str:
+        """
+        Fetch web page content.
+
+        Args:
+            url: URL to fetch
+
+        Returns:
+            Extracted text content
+        """
+        if ollama is None:
+            raise ImportError(
+                "ollama is required for web tools. Install it with: uv add ollama"
+            )
+
+        try:
+            fetch_func = getattr(ollama, "web_fetch", None)
+
+            if not fetch_func:
+                raise NotImplementedError(
+                    "ollama.web_fetch is not available in the installed library version."
+                )
+
+            response = fetch_func(url=url)
+
+            # Return content (assuming response implies content string or dict with content)
+            if isinstance(response, dict):
+                content = response.get("content", str(response))
+            else:
+                content = str(response)
+
+            # Ensure the content is JSON serializable
+            try:
+                json.dumps(content)  # Test if serializable
+                return content
+            except TypeError:
+                return str(content)  # Convert non-serializable to string
+
+        except NotImplementedError:
+            raise
+        except Exception as e:
+            raise RuntimeError(f"Web fetch failed: {str(e)}")
+
+    async def aexecute(self, url: str) -> str:
+        """Async version of execute."""
+        import asyncio
+
+        return await asyncio.to_thread(self.execute, url)
+
+    def get_interruption_message(self, url: str, **kwargs) -> str:
+        """Get interruption message for user confirmation."""
+        return f"execute web_fetch: {url}"
+
+
+def get_web_tools() -> list[BaseTool]:
+    """Get all web tools."""
+    return [
+        WebSearchTool(),
+        WebFetchTool(),
+    ]

kader-0.1.0.dist-info/METADATA

@@ -0,0 +1,319 @@
+Metadata-Version: 2.4
+Name: kader
+Version: 0.1.0
+Summary: kader coding agent
+Requires-Python: >=3.11
+Requires-Dist: faiss-cpu>=1.9.0
+Requires-Dist: loguru>=0.7.3
+Requires-Dist: ollama>=0.6.1
+Requires-Dist: pyyaml>=6.0.3
+Requires-Dist: tenacity>=9.1.2
+Requires-Dist: textual[syntax]>=6.8.0
+Requires-Dist: typing-extensions>=4.15.0
+Requires-Dist: wcmatch>=10.1
+Description-Content-Type: text/markdown
+
+# Kader
+
+Kader is an intelligent coding agent designed to assist with software development tasks. It provides a comprehensive framework for building AI-powered agents with advanced reasoning capabilities and tool integration.
+
+## Features
+
+- 🤖 **AI-powered Code Assistance** - Using Ollama for local LLM execution
+- 🖥️ **Interactive CLI** - Modern TUI interface built with Textual
+- 🛠️ **Tool Integration** - File system, command execution, web search, and more
+- 🧠 **Memory Management** - State persistence and conversation history
+- 🔁 **Session Management** - Save and load conversation sessions
+- 🎨 **Theming** - Multiple color themes for the CLI interface
+- ⌨️ **Keyboard Shortcuts** - Efficient navigation and operations
+- 📝 **YAML Configuration** - Agent configuration via YAML files
+- 🔄 **ReAct Agent Framework** - Reasoning and Acting agent architecture
+- 🗂️ **File System Tools** - Read, write, search, and edit files
+- 🔍 **Planning Agent** - Task planning and execution capabilities
+
+## Installation
+
+### Prerequisites
+
+- Python 3.11 or higher
+- [Ollama](https://ollama.ai/) running locally to use LLMs
+- [uv](https://docs.astral.sh/uv/) package manager (recommended) or [pip](https://pypi.org/project/pip/)
+
+### Using uv (recommended)
+
+```bash
+# Clone the repository
+git clone https://github.com/your-repo/kader.git
+cd kader
+
+# Install dependencies with uv
+uv sync
+
+# Run the CLI
+uv run python -m cli
+```
+
+### Using pip
+
+```bash
+# Clone the repository
+git clone https://github.com/your-repo/kader.git
+cd kader
+
+# Install in development mode
+pip install -e .
+
+# Run the CLI
+python -m cli
+```
+
+## Quick Start
+
+### Running the CLI
+
+```bash
+# Run the Kader CLI using uv
+uv run python -m cli
+
+# Or using pip
+python -m cli
+```
+
+### First Steps in CLI
+
+Once the CLI is running:
+
+1. Type any question to start chatting with the agent
+2. Use `/help` to see available commands
+3. Use `/models` to check available models
+4. Use `/theme` to cycle through color themes
+
+## Configuration
+
+When the kader module is imported for the first time, it automatically:
+1. Creates a `.kader` directory in your home directory (`~/.kader` on Unix systems, `%USERPROFILE%\.kader` on Windows)
+2. Creates a `.env` file with the required configuration (including `OLLAMA_API_KEY=''`)
+3. Loads all environment variables from the `.env` file into the application environment
+
+### Environment Variables
+
+The application automatically loads environment variables from `~/.kader/.env`:
+- `OLLAMA_API_KEY`: API key for Ollama service (default: empty)
+- Additional variables can be added to the `.env` file and will be automatically loaded
+
+### Memory and Sessions
+
+Kader stores data in `~/.kader/`:
+- Sessions: `~/.kader/sessions/`
+- Configuration: `~/.kader/`
+- Memory files: `~/.kader/memory/`
+
+## CLI Commands
+
+| Command | Description |
+|---------|-------------|
+| `/help` | Show command reference |
+| `/models` | Show available Ollama models |
+| `/theme` | Cycle color themes |
+| `/clear` | Clear conversation |
+| `/save` | Save current session |
+| `/load <id>` | Load a saved session |
+| `/sessions` | List saved sessions |
+| `/refresh` | Refresh file tree |
+| `/exit` | Exit the CLI |
+
+### Keyboard Shortcuts
+
+| Shortcut | Action |
+|----------|--------|
+| `Ctrl+Q` | Quit |
+| `Ctrl+L` | Clear conversation |
+| `Ctrl+T` | Cycle theme |
+| `Ctrl+S` | Save session |
+| `Ctrl+R` | Refresh file tree |
+| `Tab` | Navigate panels |
+
+## Project Structure
+
+```
+kader/
+├── cli/                    # Interactive command-line interface
+│   ├── app.py             # Main application entry point
+│   ├── app.tcss           # Textual CSS for styling
+│   ├── utils.py           # Utility functions and constants
+│   ├── widgets/           # Custom Textual widgets
+│   │   ├── conversation.py # Chat display widget
+│   │   ├── loading.py     # Loading spinner widget
+│   │   └── confirmation.py # Tool/model selection widgets
+│   └── README.md          # CLI documentation
+├── examples/              # Example implementations
+│   ├── memory_example.py  # Memory management examples
+│   ├── ollama_example.py  # Ollama provider examples
+│   ├── react_agent_example.py # ReAct agent examples
+│   ├── planning_agent_example.py # Planning agent examples
+│   ├── python_developer/  # Python expert agent example
+│   ├── todo_agent/       # Todo management agent example
+│   └── README.md         # Examples documentation
+├── kader/                # Core framework
+│   ├── agent/            # Agent implementations
+│   ├── memory/           # Memory management
+│   ├── providers/        # LLM providers
+│   ├── tools/            # Tools and utilities
+│   └── prompts/          # Prompt templates
+├── pyproject.toml        # Project dependencies
+├── README.md             # This file
+└── uv.lock               # Dependency lock file
+```
+
+## Core Components
+
+### Agents
+
+Kader provides several agent types:
+
+- **ReActAgent**: Reasoning and Acting agent that combines thoughts with actions
+- **PlanningAgent**: Agent that plans multi-step tasks
+- **BaseAgent**: Base agent class for creating custom agents
+
+### Memory Management
+
+Kader's memory system includes:
+
+- **AgentState**: Persistent key-value storage for agents
+- **RequestState**: Ephemeral request-scoped state
+- **FileSessionManager**: Session persistence to disk
+- **SlidingWindowConversationManager**: Conversation windowing
+
+### Tools
+
+Kader includes a rich set of tools:
+
+- **File System Tools**: Read, write, edit, search files
+- **Command Executor**: Execute shell commands safely
+- **Web Tools**: Search and fetch web content
+- **RAG Tools**: Retrieval Augmented Generation capabilities
+
+## Examples
+
+Check out the examples directory for comprehensive demonstrations of Kader's features:
+
+### Basic Examples
+
+- `memory_example.py`: Shows memory management capabilities
+- `ollama_example.py`: Demonstrates how to use the Ollama provider for LLM interactions
+- `tools_example.py`: Demonstrates the various tools available in Kader
+- `simple_agent.py`: Basic agent implementation example
+
+### Advanced Examples
+
+- `react_agent_example.py`: Interactive ReAct agent with tool integration
+- `planning_agent_example.py`: Planning agent for multi-step tasks
+- `python_developer/`: Specialized Python expert agent (YAML-configured)
+- `todo_agent/`: Task management agent with TodoTool
+
+### Running Examples
+
+Use uv to run examples:
+
+```bash
+uv run python -m examples.memory_example
+uv run python -m examples.ollama_example
+uv run python -m examples.tools_example
+uv run python -m examples.react_agent_example
+uv run python -m examples.python_developer.main
+uv run python -m examples.todo_agent.main
+```
+
+## Architecture
+
+### Agent Architecture
+
+Kader uses a modular architecture where:
+
+1. **Agents** define the behavior and reasoning strategy
+2. **Tools** provide capabilities for external interactions
+3. **Memory** manages state and conversation history
+4. **Providers** handle LLM interactions
+
+### Tool Architecture
+
+Tools in Kader follow a standardized interface:
+
+- Each tool has a schema defining its inputs and outputs
+- Tools can be registered in a ToolRegistry
+- Tools can be executed synchronously or asynchronously
+- Tools can be configured with parameters
+
+## Development
+
+### Setting up for Development
+
+```bash
+# Clone the repository
+git clone https://github.com/your-repo/kader.git
+cd kader
+
+# Install in development mode with uv
+uv sync
+
+# Run the CLI with hot reload for development
+uv run textual run --dev cli.app:KaderApp
+```
+
+### Running Tests
+
+```bash
+# Run tests with uv
+uv run pytest
+
+# Run tests with specific options
+uv run pytest --verbose
+```
+
+### Code Quality
+
+Kader uses various tools for maintaining code quality:
+
+```bash
+# Run linter
+uv run ruff check .
+
+# Format code
+uv run ruff format .
+```
+
+## Troubleshooting
+
+### Common Issues
+
+- **No models found**: Make sure Ollama is running and you have at least one model installed (e.g., `ollama pull gpt-oss:120b-cloud`)
+- **Connection errors**: Verify that Ollama service is accessible at the configured endpoint
+- **Theme not changing**: Some terminal emulators may not support all color themes
+
+### Debugging
+
+If you encounter issues:
+
+1. Check that Ollama is running: `ollama serve`
+2. Verify your model is pulled: `ollama list`
+3. Ensure your terminal supports the required features
+4. Check the logs for specific error messages
+
+## Contributing
+
+1. Fork the repository
+2. Create a feature branch
+3. Make your changes
+4. Add tests if applicable
+5. Run the test suite
+6. Submit a pull request
+
+## License
+
+This project is licensed under the MIT License - see the LICENSE file for details.
+
+## Acknowledgments
+
+- Built with [Textual](https://textual.textualize.io/) for the beautiful CLI interface
+- Uses [Ollama](https://ollama.ai/) for local LLM execution
+- Inspired by ReAct (Reasoning and Acting) agent architecture

kader-0.1.0.dist-info/RECORD

@@ -0,0 +1,45 @@
+cli/README.md,sha256=DY3X7w6LPka1GzhtTrGwhpkFmx0YyRpcTCHjFmti3Yg,4654
+cli/__init__.py,sha256=OAi_KSwcuYXR0sRxKuw1DYQrz1jbu8p7vn41_99f36I,107
+cli/__main__.py,sha256=xO2JVjCsh691b-cjSBAEKocJeUeI3P0gfUqM-f1Mp1A,95
+cli/app.py,sha256=eEWrfq_XobsjAeSc2lRMNBJ1cs2nlZ_qeoamuqSnubg,19981
+cli/app.tcss,sha256=eJX5akeqHmoZVDjibvBPIBot5UK7eiUxgojNu9IjMBs,10098
+cli/utils.py,sha256=jt5wvSMIjPP-ZbvXEK2fd00-oRj32sj95HinJd4c73Q,1815
+cli/widgets/__init__.py,sha256=1vj31CrJyxZROLthkKr79i_GbNyj8g3q60ZQPbJHK5k,300
+cli/widgets/confirmation.py,sha256=s6h3ZY98xHeeF3G-OtHYYw-xPlAP6K7i73jo_ftOMQc,9400
+cli/widgets/conversation.py,sha256=vqI3eq7qQrn4UD8fB8rBr33kIesrLpNVhNIp3MdGeOM,1519
+cli/widgets/loading.py,sha256=xME_riHCJ0smN9Fo-usa45WEfGLmkdcf9ntMqnZAztA,1703
+kader/__init__.py,sha256=QXb0aQvySAiNmhP2kNMNtuuzG_eSUgRVcTRSafko1r0,602
+kader/config.py,sha256=B1s1PNgZ5SrFEJU5TtJG-ZAc7Umff4cwyHR7mfQgeLA,4261
+kader/agent/__init__.py,sha256=UJzUw9NIzggCrhIBHC6nJnfzkhCjCZnIzmD6uUn2SNA,159
+kader/agent/agents.py,sha256=lo41hlkPm3CStI9VAwSOR6IYhCBkqQJ48Ego5XN1XU8,4299
+kader/agent/base.py,sha256=qWT53Fuw3I61X9wvZFDNJ8YnYSxBJKdnOH1122cWP2s,36452
+kader/agent/logger.py,sha256=Y8Ig6Jab_jEDUCStAnv-zmBf8u7Ubpe5ry-zaPmj0Kk,6582
+kader/memory/__init__.py,sha256=VUzzhGOWvO_2aYB6uuavmtNI8l94K7H3uPn4_1MVUUs,1473
+kader/memory/conversation.py,sha256=h6Bamd8_rYnk0Bwt4MJWZRfv2wxCcg6eUxPvzP-tIyA,11810
+kader/memory/session.py,sha256=VhRPEO474SlwM5UOuFt-b_28sJs3j4SNrobCZvoP5Os,10811
+kader/memory/state.py,sha256=itwRjA4PvLlqlRStu-PnMWgSNsMTeU7R0qPOuj0mVDM,5722
+kader/memory/types.py,sha256=h8B40dupNHNZgYC9WJ4hArnlUbX28Pv-XtgIcfUeqQw,3338
+kader/prompts/__init__.py,sha256=TS1kYmEX6TkZcB9GDiulZLI0i9RvFuqMR_kPZEn7AZU,230
+kader/prompts/agent_prompts.py,sha256=Gn3LKPlVLNy3JMWmtv4jcGr5jXu_YcR-0Y4qHjq-Y_s,809
+kader/prompts/base.py,sha256=mFfPfuTX7VNjjiBqez10S7oxyNpiw9U63hTVVAPmlKY,2387
+kader/prompts/templates/planning_agent.j2,sha256=Uc4SnMPv4vKWchhO0RLRNjbEio5CVlRgqDJG_dgM2Pk,1315
+kader/prompts/templates/react_agent.j2,sha256=yME6Qgj2WTW8jRZ_yuQcY6xlXKcV7YUv5sz5ZfCl8P4,606
+kader/providers/__init__.py,sha256=DYEZakt2SRy0Xd2vem93V_TRlY2s19KaJC9bSaOB1WY,154
+kader/providers/base.py,sha256=gxpomjRAX9q3Qf4GHYxdiGI_GsRW9BG7PM38SKUAeCk,17105
+kader/providers/mock.py,sha256=VBuOFFPvDWn4QVFS9HXlwu3jswP0NNNxrMyL4Qgvm50,2723
+kader/providers/ollama.py,sha256=lTuwzFFPMmlD5xBhK_mYG2AvTA0-OLcPDfPwc3lLkTQ,15557
+kader/tools/README.md,sha256=lmw-Ghm8ie2pNcSTL4sJ7OKerkGvbXmlD9Zi87hiC-8,14347
+kader/tools/__init__.py,sha256=6h4Tif5VcYyaL18b_feM91LEF_9nXqcaQwaQ920wRI0,2527
+kader/tools/base.py,sha256=oHqY1-5ihcH4ilvuHd-c5Vb81xm3jAlMrkRlR_8wltE,28840
+kader/tools/exec_commands.py,sha256=nRKkV84Q8b9kHn8vSIKYe6eKhLx9pGRL-5C1hC11-7Y,7948
+kader/tools/filesys.py,sha256=offjTGg1cOolwAGnGnnKguh3225tbVUUu-ipJ2TpaC8,19570
+kader/tools/filesystem.py,sha256=ANTyiFgdxvYSWbp-hSH0AxGH_x-gx2V6XwYypE2MtoM,22733
+kader/tools/protocol.py,sha256=xyLc-5xY1f9VvumnruoJpLldRk3vzDi1WEDcYXgH7o4,15825
+kader/tools/rag.py,sha256=37Nd49D5R_DlWmMyhSdSvst_XFOnoxpaFNtlbLEt6qM,15653
+kader/tools/todo.py,sha256=omirxoG7_KVHAmMoD12DGmn7scqRaewbI1cqWm0ShUo,7735
+kader/tools/utils.py,sha256=bfq7b1vpA1qBaL_QZYBFTqOM35-omu_UeDjo6v0rxEg,14176
+kader/tools/web.py,sha256=2Aqy0nO7ZwNLAqE9IWjCg5y8qnhbt-AIZOHy02XgbxA,8464
+kader-0.1.0.dist-info/METADATA,sha256=J_DfNeYzT6xLF8XAv4CB6UC2s_niBJ4zHznt8g0VEOk,9461
+kader-0.1.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+kader-0.1.0.dist-info/entry_points.txt,sha256=TK0VOtrfDFqZ8JQfxpuAHHvDLHyoiafUjS-VOixl02c,39
+kader-0.1.0.dist-info/RECORD,,

kader-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.28.0
+Root-Is-Purelib: true
+Tag: py3-none-any

kader-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+kader = cli.app:main