devduck 0.1.0__py3-none-any.whl

devduck/install.sh

@@ -0,0 +1,42 @@
+#!/bin/bash
+# 🦆 DevDuck installer - Extreme minimalist agent
+
+echo "🦆 Installing Devduck..."
+
+# Check Python
+if ! command -v python3 &> /dev/null; then
+    echo "❌ Python 3 not found. Please install Python 3.8+"
+    exit 1
+fi
+
+# Check Ollama  
+if ! command -v ollama &> /dev/null; then
+    echo "⚠️  Ollama not found. Installing..."
+    if [[ "$OSTYPE" == "darwin"* ]]; then
+        # macOS
+        if command -v brew &> /dev/null; then
+            brew install ollama
+        else
+            curl -fsSL https://ollama.ai/install.sh | sh
+        fi
+    else
+        # Linux
+        curl -fsSL https://ollama.ai/install.sh | sh
+    fi
+fi
+
+# Start ollama service
+echo "🦆 Starting Ollama service..."
+ollama serve &
+sleep 2
+
+# Pull a basic model
+echo "🦆 Pulling basic model..."
+ollama pull qwen3:1.7b
+
+# Test devduck
+echo "🦆 Testing Devduck..."
+python3 __init__.py "what's 5*7?"
+
+echo "✅ Devduck installed successfully!"
+echo "Usage: python3 __init__.py 'your question'"

devduck/test_redduck.py

@@ -0,0 +1,79 @@
+#!/usr/bin/env python3
+"""🦆 DevDuck test suite"""
+
+
+def test_import():
+    """Test basic import and initialization"""
+    try:
+        import devduck
+
+        print("✅ Import successful")
+        return True
+    except Exception as e:
+        print(f"❌ Import failed: {e}")
+        return False
+
+
+def test_status():
+    """Test status function"""
+    try:
+        import devduck
+
+        status = devduck.status()
+        print(f"✅ Status: {status}")
+        return True
+    except Exception as e:
+        print(f"❌ Status failed: {e}")
+        return False
+
+
+def test_basic_query():
+    """Test basic agent query"""
+    try:
+        import devduck
+
+        result = devduck.ask("what's 2+2?")
+        print(f"✅ Query result: {result}")
+        return True
+    except Exception as e:
+        print(f"❌ Query failed: {e}")
+        return False
+
+
+def test_time_query():
+    """Test current time tool"""
+    try:
+        import devduck
+
+        result = devduck.ask("what time is it?")
+        print(f"✅ Time query: {result}")
+        return True
+    except Exception as e:
+        print(f"❌ Time query failed: {e}")
+        return False
+
+
+def run_tests():
+    """Run all tests"""
+    print("🦆 Testing Devduck...")
+
+    tests = [test_import, test_status, test_basic_query, test_time_query]
+
+    results = []
+    for test in tests:
+        print(f"\n🧪 Running {test.__name__}...")
+        results.append(test())
+
+    passed = sum(results)
+    total = len(results)
+
+    print(f"\n🦆 Results: {passed}/{total} tests passed")
+
+    if passed == total:
+        print("🎉 All tests passed! Devduck is ready to go!")
+    else:
+        print("⚠️  Some tests failed. Check ollama service and dependencies.")
+
+
+if __name__ == "__main__":
+    run_tests()

devduck/tools/tcp.py

@@ -0,0 +1,457 @@
+"""TCP tool for Strands Agents to function as both server and client.
+
+This module provides TCP server and client functionality for Strands Agents,
+allowing them to communicate over TCP/IP networks. The tool runs server operations
+in background threads, enabling concurrent communication without blocking the main agent.
+
+Key Features:
+1. TCP Server: Listen for incoming connections and process them with an agent
+2. TCP Client: Connect to remote TCP servers and exchange messages
+3. Background Processing: Server runs in a background thread
+4. Per-Connection Agents: Creates a fresh agent for each client connection
+
+Usage with Strands Agent:
+
+```python
+from strands import Agent
+from strands_tools import tcp
+
+agent = Agent(tools=[tcp])
+
+# Start a TCP server
+result = agent.tool.tcp(
+    action="start_server",
+    host="127.0.0.1",
+    port=8000,
+    system_prompt="You are a helpful TCP server assistant.",
+)
+
+# Connect to a TCP server as client
+result = agent.tool.tcp(
+    action="client_send", host="127.0.0.1", port=8000, message="Hello, server!"
+)
+
+# Stop the TCP server
+result = agent.tool.tcp(action="stop_server", port=8000)
+```
+
+See the tcp function docstring for more details on configuration options and parameters.
+"""
+
+import logging
+import socket
+import threading
+import time
+from typing import Any
+
+from strands import Agent, tool
+
+logger = logging.getLogger(__name__)
+
+# Global registry to store server threads
+SERVER_THREADS: dict[int, dict[str, Any]] = {}
+
+
+def handle_client(
+    client_socket: socket.socket,
+    client_address: tuple,
+    system_prompt: str,
+    buffer_size: int,
+    model: Any,
+    parent_tools: list | None = None,
+    callback_handler: Any = None,
+    trace_attributes: dict | None = None,
+) -> None:
+    """Handle a client connection in the TCP server.
+
+    Args:
+        client_socket: The socket for the client connection
+        client_address: The address of the client
+        system_prompt: System prompt for creating a new agent for this connection
+        buffer_size: Size of the message buffer
+        model: Model instance from parent agent
+        parent_tools: Tools inherited from the parent agent
+        callback_handler: Callback handler from parent agent
+        trace_attributes: Trace attributes from the parent agent
+    """
+    logger.info(f"Connection established with {client_address}")
+
+    # Create a fresh agent instance for this client connection
+    connection_agent = Agent(
+        model=model,
+        messages=[],
+        tools=parent_tools or [],
+        callback_handler=callback_handler,
+        system_prompt=system_prompt,
+        trace_attributes=trace_attributes or {},
+    )
+
+    try:
+        # Send welcome message
+        welcome_msg = "Welcome to Strands TCP Server! Send a message or 'exit' to close the connection.\n"
+        client_socket.sendall(welcome_msg.encode())
+
+        while True:
+            # Receive data from the client
+            data = client_socket.recv(buffer_size)
+
+            if not data:
+                logger.info(f"Client {client_address} disconnected")
+                break
+
+            message = data.decode().strip()
+            logger.info(f"Received from {client_address}: {message}")
+
+            if message.lower() == "exit":
+                client_socket.sendall(b"Connection closed by client request.\n")
+                logger.info(f"Client {client_address} requested to exit")
+                break
+
+            # Process the message with the connection-specific agent
+            response = connection_agent(message)
+            response_text = str(response)
+
+            # Send the response back to the client
+            client_socket.sendall((response_text + "\n").encode())
+
+    except Exception as e:
+        logger.error(f"Error handling client {client_address}: {e}")
+    finally:
+        client_socket.close()
+        logger.info(f"Connection with {client_address} closed")
+
+
+def run_server(
+    host: str,
+    port: int,
+    system_prompt: str,
+    max_connections: int,
+    buffer_size: int,
+    parent_agent: Agent | None = None,
+) -> None:
+    """Run a TCP server that processes client requests with per-connection Strands agents.
+
+    Args:
+        host: Host address to bind the server
+        port: Port number to bind the server
+        system_prompt: System prompt for the server agents
+        max_connections: Maximum number of concurrent connections
+        buffer_size: Size of the message buffer
+        parent_agent: Parent agent to inherit tools from
+    """
+    # Store server state
+    SERVER_THREADS[port]["running"] = True
+    SERVER_THREADS[port]["connections"] = 0
+    SERVER_THREADS[port]["start_time"] = time.time()
+
+    # Get model, tools, callback_handler and trace attributes from parent agent
+    model = None
+    callback_handler = None
+    parent_tools = []
+    trace_attributes = {}
+    if parent_agent:
+        model = parent_agent.model
+        callback_handler = parent_agent.callback_handler
+        parent_tools = list(parent_agent.tool_registry.registry.values())
+        trace_attributes = parent_agent.trace_attributes
+
+    # Create server socket
+    server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+    server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+
+    try:
+        server_socket.bind((host, port))
+        server_socket.listen(max_connections)
+        logger.info(f"TCP Server listening on {host}:{port}")
+
+        SERVER_THREADS[port]["socket"] = server_socket
+
+        while SERVER_THREADS[port]["running"]:
+            # Set a timeout to check periodically if the server should stop
+            server_socket.settimeout(1.0)
+
+            try:
+                # Accept client connection
+                client_socket, client_address = server_socket.accept()
+                SERVER_THREADS[port]["connections"] += 1
+
+                # Handle client in a new thread with a fresh agent
+                client_thread = threading.Thread(
+                    target=handle_client,
+                    args=(
+                        client_socket,
+                        client_address,
+                        system_prompt,
+                        buffer_size,
+                        model,
+                        parent_tools,
+                        callback_handler,
+                        trace_attributes,
+                    ),
+                )
+                client_thread.daemon = True
+                client_thread.start()
+
+            except TimeoutError:
+                # This is expected due to the timeout, allows checking if server should stop
+                pass
+            except Exception as e:
+                if SERVER_THREADS[port]["running"]:
+                    logger.error(f"Error accepting connection: {e}")
+
+    except Exception as e:
+        logger.error(f"Server error on {host}:{port}: {e}")
+    finally:
+        try:
+            server_socket.close()
+        except OSError:
+            # Socket already closed, safe to ignore
+            pass
+        logger.info(f"TCP Server on {host}:{port} stopped")
+        SERVER_THREADS[port]["running"] = False
+
+
+@tool
+def tcp(
+    action: str,
+    host: str = "127.0.0.1",
+    port: int = 8000,
+    system_prompt: str = "You are a helpful TCP server assistant.",
+    message: str = "",
+    timeout: int = 90,
+    buffer_size: int = 4096,
+    max_connections: int = 5,
+    agent: Any = None,
+) -> dict:
+    """Create and manage TCP servers and clients for network communication with connection handling.
+
+    This function provides TCP server and client functionality for Strands agents,
+    allowing them to communicate over TCP/IP networks. Servers run in background
+    threads with a new, fresh agent instance for each client connection.
+
+    How It Works:
+    ------------
+    1. Server Mode:
+       - Starts a TCP server in a background thread
+       - Creates a dedicated agent for EACH client connection
+       - Inherits tools from the parent agent
+       - Processes client messages and returns responses
+
+    2. Client Mode:
+       - Connects to a TCP server
+       - Sends messages and receives responses
+       - Maintains stateless connections (no persistent sessions)
+
+    3. Management:
+       - Track server status and statistics
+       - Stop servers gracefully
+       - Monitor connections and performance
+
+    Common Use Cases:
+    ---------------
+    - Network service automation
+    - Inter-agent communication
+    - Remote command and control
+    - API gateway implementation
+    - IoT device management
+
+    Args:
+        action: Action to perform (start_server, stop_server, get_status, client_send)
+        host: Host address for server or client connection
+        port: Port number for server or client connection
+        system_prompt: System prompt for the server agent (for start_server)
+        message: Message to send to the TCP server (for client_send action)
+        timeout: Connection timeout in seconds (default: 90)
+        buffer_size: Size of the message buffer in bytes (default: 4096)
+        max_connections: Maximum number of concurrent connections (default: 5)
+
+    Returns:
+        Dictionary containing status and response content
+
+    Notes:
+        - Server instances persist until explicitly stopped
+        - Each client connection gets its own agent instance
+        - Connection agents inherit tools from the parent agent
+        - Client connections are stateless
+    """
+    # Get parent agent from tool context if available
+    parent_agent = agent
+
+    if action == "start_server":
+        # Check if server already running on this port
+        if port in SERVER_THREADS and SERVER_THREADS[port].get("running", False):
+            return {
+                "status": "error",
+                "content": [{"text": f"❌ Error: TCP Server already running on port {port}"}],
+            }
+
+        # Create server thread
+        SERVER_THREADS[port] = {"running": False}
+        server_thread = threading.Thread(
+            target=run_server,
+            args=(
+                host,
+                port,
+                system_prompt,
+                max_connections,
+                buffer_size,
+                parent_agent,
+            ),
+        )
+        server_thread.daemon = True
+        server_thread.start()
+
+        # Wait briefly to ensure server starts
+        time.sleep(0.5)
+
+        if not SERVER_THREADS[port].get("running", False):
+            return {
+                "status": "error",
+                "content": [{"text": f"❌ Error: Failed to start TCP Server on {host}:{port}"}],
+            }
+
+        return {
+            "status": "success",
+            "content": [
+                {"text": f"✅ TCP Server started successfully on {host}:{port}"},
+                {"text": f"System prompt: {system_prompt}"},
+                {"text": "Server creates a new agent instance for each connection"},
+            ],
+        }
+
+    elif action == "stop_server":
+        if port not in SERVER_THREADS or not SERVER_THREADS[port].get("running", False):
+            return {
+                "status": "error",
+                "content": [{"text": f"❌ Error: No TCP Server running on port {port}"}],
+            }
+
+        # Stop the server
+        SERVER_THREADS[port]["running"] = False
+
+        # Close socket if it exists
+        if "socket" in SERVER_THREADS[port]:
+            try:
+                SERVER_THREADS[port]["socket"].close()
+            except OSError:
+                # Socket already closed, safe to ignore
+                pass
+
+        # Wait briefly to ensure server stops
+        time.sleep(1.0)
+
+        connections = SERVER_THREADS[port].get("connections", 0)
+        uptime = time.time() - SERVER_THREADS[port].get("start_time", time.time())
+
+        # Clean up server thread data
+        del SERVER_THREADS[port]
+
+        return {
+            "status": "success",
+            "content": [
+                {"text": f"✅ TCP Server on port {port} stopped successfully"},
+                {"text": f"Statistics: {connections} connections handled, uptime {uptime:.2f} seconds"},
+            ],
+        }
+
+    elif action == "get_status":
+        if not SERVER_THREADS:
+            return {
+                "status": "success",
+                "content": [{"text": "No TCP Servers running"}],
+            }
+
+        status_info = []
+        for port, data in SERVER_THREADS.items():
+            if data.get("running", False):
+                uptime = time.time() - data.get("start_time", time.time())
+                connections = data.get("connections", 0)
+                status_info.append(f"Port {port}: Running - {connections} connections, uptime {uptime:.2f}s")
+            else:
+                status_info.append(f"Port {port}: Stopped")
+
+        return {
+            "status": "success",
+            "content": [
+                {"text": "TCP Server Status:"},
+                {"text": "\n".join(status_info)},
+            ],
+        }
+
+    elif action == "client_send":
+        host = host
+        port = port
+        message = message
+        timeout = timeout
+        buffer_size = buffer_size
+
+        if not message:
+            return {
+                "status": "error",
+                "content": [{"text": "Error: No message provided for client_send action"}],
+            }
+
+        # Create client socket
+        client_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+        client_socket.settimeout(timeout)
+
+        try:
+            # Connect to server
+            client_socket.connect((host, port))
+
+            # Receive welcome message
+            _welcome = client_socket.recv(buffer_size).decode()
+
+            # Send message to server
+            client_socket.sendall(message.encode())
+
+            # Receive response
+            response = client_socket.recv(buffer_size).decode()
+
+            # Send exit message and close connection
+            client_socket.sendall(b"exit")
+            client_socket.close()
+
+            return {
+                "status": "success",
+                "content": [
+                    {"text": f"Connected to {host}:{port} successfully"},
+                    {"text": f"Received welcome message: {_welcome}"},
+                    {"text": f"Sent message: {message}"},
+                    {"text": "Response received:"},
+                    {"text": response},
+                ],
+            }
+
+        except TimeoutError:
+            return {
+                "status": "error",
+                "content": [{"text": f"Error: Connection to {host}:{port} timed out after {timeout} seconds"}],
+            }
+        except ConnectionRefusedError:
+            return {
+                "status": "error",
+                "content": [{"text": f"Error: Connection to {host}:{port} refused - no server running on that port"}],
+            }
+        except Exception as e:
+            return {
+                "status": "error",
+                "content": [{"text": f"Error connecting to {host}:{port}: {e!s}"}],
+            }
+        finally:
+            try:
+                client_socket.close()
+            except OSError:
+                # Socket already closed, safe to ignore
+                pass
+
+    else:
+        return {
+            "status": "error",
+            "content": [
+                {
+                    "text": f"Error: Unknown action '{action}'. Supported actions are: "
+                    f"start_server, stop_server, get_status, client_send"
+                }
+            ],
+        }

devduck-0.1.0.dist-info/METADATA

@@ -0,0 +1,106 @@
+Metadata-Version: 2.4
+Name: devduck
+Version: 0.1.0
+Summary: 🦆 Extreme minimalist self-adapting AI agent - one file, self-healing, runtime dependencies
+Home-page: https://github.com/cagataycali/devduck
+Author: maxs
+Author-email: duck <hey@devduck.dev>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/cagataycali/devduck
+Project-URL: Repository, https://github.com/cagataycali/devduck.git
+Project-URL: Documentation, https://github.com/cagataycali/devduck#readme
+Project-URL: Bug Tracker, https://github.com/cagataycali/devduck/issues
+Keywords: ai,agent,minimalist,self-healing,ollama,strands-agents
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: System Administrators
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: System :: Systems Administration
+Classifier: Topic :: Utilities
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: strands-agents
+Requires-Dist: strands-agents[ollama]
+Requires-Dist: strands-agents[openai]
+Requires-Dist: strands-agents[anthropic]
+Requires-Dist: strands-agents-tools
+Dynamic: author
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: requires-python
+
+# 🦆 DevDuck
+
+**One file. Self-healing. Adaptive.**
+
+Minimalist AI agent that fixes itself when things break.
+
+## Install
+
+```bash
+pipx install devduck
+```
+
+Requires: Python 3.10+, Ollama running
+
+## Use
+
+```bash
+# CLI
+devduck "what's the time?"
+
+# Interactive
+devduck
+
+# Python
+import devduck
+
+devduck("calculate 2+2")
+```
+
+## Features
+
+- **Self-healing** - Auto-fixes deps, models, errors
+- **Hot-reload** - Create tools in `./tools/*.py`, use instantly
+- **Adaptive** - Picks model based on OS (macOS: 1.7b, Linux: 30b)
+- **14 tools** - shell, editor, files, python, calculator, tcp, etc.
+- **History aware** - Remembers shell/conversation context
+
+## Create Tool
+
+```python
+# ./tools/greet.py
+from strands import tool
+
+@tool
+def greet(name: str) -> str:
+    return f"Hello {name}!"
+```
+
+Save. Done. Use immediately.
+
+## Multi-Model
+
+```bash
+export MODEL_PROVIDER="bedrock"
+export STRANDS_MODEL_ID="us.anthropic.claude-sonnet-4-5-20250929-v1:0"
+export STRANDS_ADDITIONAL_REQUEST_FIELDS='{"anthropic_beta": ["interleaved-thinking-2025-05-14", "context-1m-2025-08-07"], "thinking": {"type": "enabled", "budget_tokens": 2048}}'
+export STRANDS_MAX_TOKENS="64000"
+
+devduck "analyze data"
+```
+
+---
+
+**Quack.** 🦆
+
+*Built with [Strands Agents SDK](https://github.com/strands-agents/sdk-python)*

devduck-0.1.0.dist-info/RECORD

@@ -0,0 +1,11 @@
+devduck/__init__.py,sha256=AaMXDIqX4j7FUfIF5rvdkJcSlLLtclHpuIQ5HeiiDQ4,34903
+devduck/install.sh,sha256=tYq2WWZFCBEMbxCneKAw3GSNAG1zNhpd-kzW1l5ZISw,990
+devduck/test_redduck.py,sha256=nqRchR7d54jWGx7JN5tji2ZV4Ek4L9s-P7hp0mKjA0Y,1773
+devduck/tools/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+devduck/tools/tcp.py,sha256=zK8mrWh9-v3acIJ_qWzr9hi-SaONI4u7ScUWEuxWhN8,15477
+devduck-0.1.0.dist-info/licenses/LICENSE,sha256=CVGEiNh6cW1mgAKW83Q0P4xrQEXvqc6W-rb789W_IHM,1060
+devduck-0.1.0.dist-info/METADATA,sha256=x5csUDki9FxOvSTopwOOatfCpVWH1Z9QYvi5mYHRzJI,2971
+devduck-0.1.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+devduck-0.1.0.dist-info/entry_points.txt,sha256=BAMQaIg_BLZQOTk12bT7hy1dE9oGPLt-_dTbI4cnBnQ,40
+devduck-0.1.0.dist-info/top_level.txt,sha256=ySXWlVronp8xHYfQ_Hdfr463e0EnbWuqyuxs94EU7yk,8
+devduck-0.1.0.dist-info/RECORD,,

devduck-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+