devduck 0.1.1766644714__py3-none-any.whl → 0.3.0__py3-none-any.whl

devduck/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '0.1.1766644714'
-__version_tuple__ = version_tuple = (0, 1, 1766644714)
+__version__ = version = '0.3.0'
+__version_tuple__ = version_tuple = (0, 3, 0)
 
 __commit_id__ = commit_id = None

devduck/test_redduck.py

@@ -1,3 +1,4 @@
+#!/usr/bin/env python3
 """🦆 DevDuck test suite"""
 
 

devduck/tools/__init__.py

@@ -1,47 +1,7 @@
-"""
-DevDuck Tools Package
+"""DevDuck tools package."""
 
-This module exports all available tools for devduck.
-"""
-
-from .agentcore_agents import agentcore_agents
-from .agentcore_config import agentcore_config
-from .agentcore_invoke import agentcore_invoke
-from .agentcore_logs import agentcore_logs
-from .ambient import ambient
-from .create_subagent import create_subagent
-from .fetch_github_tool import fetch_github_tool
-from .install_tools import install_tools
-from .ipc import ipc
-from .mcp_server import mcp_server
-from .scraper import scraper
-from .speech_to_speech import speech_to_speech
-from .state_manager import state_manager
-from .store_in_kb import store_in_kb
-from .system_prompt import system_prompt
 from .tcp import tcp
-from .tray import tray
-from .use_github import use_github
-from .websocket import websocket
+from .mcp_server import mcp_server
+from .install_tools import install_tools
 
-__all__ = [
-    "agentcore_agents",
-    "agentcore_config",
-    "agentcore_invoke",
-    "agentcore_logs",
-    "ambient",
-    "create_subagent",
-    "fetch_github_tool",
-    "install_tools",
-    "ipc",
-    "mcp_server",
-    "scraper",
-    "speech_to_speech",
-    "state_manager",
-    "store_in_kb",
-    "system_prompt",
-    "tcp",
-    "tray",
-    "use_github",
-    "websocket",
-]
+__all__ = ["tcp", "mcp_server", "install_tools"]

devduck/tools/install_tools.py

@@ -29,7 +29,7 @@ def install_tools(
     and loading their tools into the agent's registry at runtime.
 
     Args:
-        action: Action to perform - "install", "load", "install_and_load", "list_loaded", "list_available"
+        action: Action to perform - "install", "load", "install_and_load", "list_loaded"
         package: Python package to install (e.g., "strands-agents-tools", "strands-fun-tools")
         module: Module to import tools from (e.g., "strands_tools", "strands_fun_tools")
         tool_names: Optional list of specific tools to load. If None, loads all available tools
@@ -39,13 +39,6 @@ def install_tools(
         Result dictionary with status and content
 
     Examples:
-        # List available tools in a package (without loading)
-        install_tools(
-            action="list_available",
-            package="strands-fun-tools",
-            module="strands_fun_tools"
-        )
-
         # Install and load all tools from strands-agents-tools
         install_tools(
             action="install_and_load",
@@ -86,15 +79,13 @@ def install_tools(
             return _load_tools_from_module(module, tool_names, agent)
         elif action == "list_loaded":
             return _list_loaded_tools(agent)
-        elif action == "list_available":
-            return _list_available_tools(package, module)
         else:
             return {
                 "status": "error",
                 "content": [
                     {
                         "text": f"❌ Unknown action: {action}\n\n"
-                        f"Valid actions: install, load, install_and_load, list_loaded, list_available"
+                        f"Valid actions: install, load, install_and_load, list_loaded"
                     }
                 ],
             }
@@ -315,95 +306,3 @@ def _list_loaded_tools(agent: Any) -> Dict[str, Any]:
             "status": "error",
             "content": [{"text": f"❌ Failed to list tools: {str(e)}"}],
         }
-
-
-def _list_available_tools(package: Optional[str], module: str) -> Dict[str, Any]:
-    """List available tools in a package without loading them."""
-    if not module:
-        return {
-            "status": "error",
-            "content": [
-                {"text": "❌ module parameter is required for list_available action"}
-            ],
-        }
-
-    try:
-        # Try to import the module
-        try:
-            imported_module = importlib.import_module(module)
-            logger.info(f"Module {module} already installed")
-        except ImportError:
-            # Module not installed - try to install package first
-            if not package:
-                return {
-                    "status": "error",
-                    "content": [
-                        {
-                            "text": f"❌ Module {module} not found and no package specified to install.\n\n"
-                            f"Please provide the 'package' parameter to install first."
-                        }
-                    ],
-                }
-
-            logger.info(f"Module {module} not found, installing package {package}")
-            install_result = _install_package(package)
-            if install_result["status"] == "error":
-                return install_result
-
-            # Try importing again after installation
-            try:
-                imported_module = importlib.import_module(module)
-            except ImportError as e:
-                return {
-                    "status": "error",
-                    "content": [
-                        {
-                            "text": f"❌ Failed to import {module} even after installing {package}: {str(e)}"
-                        }
-                    ],
-                }
-
-        # Discover tools in the module
-        available_tools = {}
-        for attr_name in dir(imported_module):
-            attr = getattr(imported_module, attr_name)
-            # Check if it's a tool (has tool_name and tool_spec attributes)
-            if hasattr(attr, "tool_name") and hasattr(attr, "tool_spec"):
-                tool_spec = attr.tool_spec
-                description = tool_spec.get("description", "No description available")
-                available_tools[attr.tool_name] = description
-
-        if not available_tools:
-            return {
-                "status": "success",
-                "content": [{"text": f"⚠️  No tools found in module: {module}"}],
-            }
-
-        # Build result message
-        result_lines = [
-            f"📦 **Available Tools in {module} ({len(available_tools)})**\n"
-        ]
-
-        for tool_name, description in sorted(available_tools.items()):
-            # Truncate long descriptions
-            if len(description) > 100:
-                description = description[:97] + "..."
-
-            result_lines.append(f"**{tool_name}**")
-            result_lines.append(f"  {description}\n")
-
-        result_lines.append(f"\n💡 To load these tools, use:")
-        result_lines.append(f"   install_tools(action='load', module='{module}')")
-        result_lines.append(f"   # Or load specific tools:")
-        result_lines.append(
-            f"   install_tools(action='load', module='{module}', tool_names=['tool1', 'tool2'])"
-        )
-
-        return {"status": "success", "content": [{"text": "\n".join(result_lines)}]}
-
-    except Exception as e:
-        logger.exception(f"Error listing available tools from {module}")
-        return {
-            "status": "error",
-            "content": [{"text": f"❌ Failed to list available tools: {str(e)}"}],
-        }

devduck/tools/mcp_server.py

@@ -190,11 +190,9 @@ def _start_mcp_server(
             agent_invoke_tool = types.Tool(
                 name="devduck",
                 description=(
-                    "Invoke a FULL DevDuck instance with complete capabilities. "
-                    "Each invocation creates a fresh DevDuck agent with self-healing, "
-                    "hot-reload, all tools, knowledge base integration, and system prompt building. "
-                    "Use this for complex queries requiring reasoning, multi-tool orchestration, "
-                    "or when you need the complete DevDuck experience via MCP."
+                    "Invoke the full DevDuck agent with a natural language prompt. "
+                    "Use this for complex queries that require reasoning across multiple tools "
+                    "or when you need a conversational response from the agent."
                 ),
                 inputSchema={
                     "type": "object",
@@ -230,7 +228,7 @@ def _start_mcp_server(
             try:
                 logger.debug(f"call_tool: name={name}, arguments={arguments}")
 
-                # Handle agent invocation tool - create a full DevDuck instance
+                # Handle agent invocation tool - use the devduck instance directly
                 if name == "devduck" and expose_agent:
                     prompt = arguments.get("prompt")
                     if not prompt:
@@ -243,34 +241,8 @@ def _start_mcp_server(
 
                     logger.debug(f"Invoking devduck with prompt: {prompt[:100]}...")
 
-                    # Create a NEW DevDuck instance for this MCP invocation
-                    # This gives full DevDuck power: self-healing, hot-reload, all tools, etc.
-                    try:
-                        from devduck import DevDuck
-
-                        # Create fresh DevDuck instance (no auto-start to avoid recursion)
-                        mcp_devduck = DevDuck(auto_start_servers=False)
-                        mcp_agent = mcp_devduck.agent
-
-                        if not mcp_agent:
-                            return [
-                                types.TextContent(
-                                    type="text",
-                                    text="❌ Error: Failed to create DevDuck instance",
-                                )
-                            ]
-
-                        # Execute with full DevDuck capabilities
-                        result = mcp_agent(prompt)
-
-                    except Exception as e:
-                        logger.error(f"DevDuck creation failed: {e}", exc_info=True)
-                        return [
-                            types.TextContent(
-                                type="text",
-                                text=f"❌ Error creating DevDuck instance: {str(e)}",
-                            )
-                        ]
+                    # Use the devduck agent directly (don't create a new instance)
+                    result = agent(prompt)
 
                     # Extract text response from agent result
                     response_text = str(result)

devduck/tools/tcp.py

@@ -216,6 +216,10 @@ def handle_client(
         )
 
     try:
+        # Send welcome message
+        welcome_msg = "🦆 Welcome to DevDuck TCP Server!\n"
+        welcome_msg += "Send a message or 'exit' to close the connection.\n\n"
+        streaming_handler._send(welcome_msg)
 
         while True:
             # Receive data from the client
@@ -316,12 +320,6 @@ def run_server(
                 if SERVER_THREADS[port]["running"]:
                     logger.error(f"Error accepting connection: {e}")
 
-    except OSError as e:
-        # Port conflict - handled upstream, no need for scary errors
-        if "Address already in use" in str(e):
-            logger.debug(f"Port {port} unavailable (handled upstream)")
-        else:
-            logger.error(f"Server error on {host}:{port}: {e}")
     except Exception as e:
         logger.error(f"Server error on {host}:{port}: {e}")
     finally:

devduck/tools/websocket.py

@@ -347,14 +347,8 @@ def run_websocket_server(
         asyncio.set_event_loop(loop)
         WS_SERVER_THREADS[port]["loop"] = loop
         loop.run_until_complete(start_server())
-    except OSError as e:
-        # Port conflict - handled upstream, no need for scary errors
-        if "Address already in use" in str(e) or "address already in use" in str(e):
-            logger.debug(f"Port {port} unavailable (handled upstream)")
-        else:
-            logger.error(f"WebSocket server error on {host}:{port}: {e}")
     except Exception as e:
-        logger.error(f"WebSocket server error on {host}:{port}: {e}")
+        logger.error(f"WebSocket server error on {host}:{port}: {e}", exc_info=True)
     finally:
         logger.info(f"WebSocket Server on {host}:{port} stopped")
         WS_SERVER_THREADS[port]["running"] = False

devduck-0.3.0.dist-info/METADATA

@@ -0,0 +1,152 @@
+Metadata-Version: 2.4
+Name: devduck
+Version: 0.3.0
+Summary: 🦆 Extreme minimalist self-adapting AI agent - one file, self-healing, runtime dependencies
+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: prompt_toolkit
+Requires-Dist: strands-agents[ollama]
+Requires-Dist: strands-agents-tools
+Requires-Dist: strands-agentcore-tools
+Requires-Dist: beautifulsoup4
+Requires-Dist: colorama
+Requires-Dist: websockets
+Provides-Extra: all
+Requires-Dist: strands-agents[openai]; extra == "all"
+Requires-Dist: strands-agents[anthropic]; extra == "all"
+Requires-Dist: strands-fun-tools[audio]; extra == "all"
+Requires-Dist: strands-fun-tools[vision]; extra == "all"
+Requires-Dist: strands-fun-tools[all]; extra == "all"
+Requires-Dist: strands-mcp-server; extra == "all"
+Dynamic: license-file
+
+# 🦆 DevDuck
+
+**One file. Self-healing. Adaptive.**
+
+Minimalist AI agent that fixes itself when things break.
+
+## Install
+
+```bash
+# Minimal install
+pipx install devduck
+
+# Full install (all tools)
+pipx install "devduck[all]"
+```
+
+Requires: Python 3.10+, Ollama running (or set MODEL_PROVIDER)
+
+## Use
+
+```bash
+# Start DevDuck (auto-starts TCP, WebSocket, MCP servers)
+devduck
+
+# CLI mode
+devduck "what's the time?"
+
+# Python
+import devduck
+devduck("calculate 2+2")
+```
+
+## Auto-Started Servers
+
+When you run `devduck`, three servers start automatically:
+
+- **🌐 Web UI**: [http://cagataycali.github.io/devduck](http://cagataycali.github.io/devduck) (auto-connects)
+- **🔌 TCP**: `nc localhost 9999` (raw socket)
+- **🌊 WebSocket**: `ws://localhost:8080` (structured JSON)
+- **🔗 MCP**: `http://localhost:8000/mcp` (Model Context Protocol)
+
+### Connect via MCP
+
+Add to your MCP client (e.g., Claude Desktop):
+
+```json
+{
+  "mcpServers": {
+    "devduck": {
+      "command": "uvx",
+      "args": [
+        "strands-mcp-server",
+        "--upstream-url",
+        "http://localhost:8000/mcp/"
+      ],
+      "disabled": false
+    }
+  }
+}
+```
+
+### Connect via Terminal
+
+```bash
+# Direct TCP connection
+nc localhost 9999
+> what's the time?
+```
+
+## 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
+- **Multi-protocol** - TCP, WebSocket, MCP, CLI, Python
+
+## 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.3.0.dist-info/RECORD

@@ -0,0 +1,18 @@
+devduck/__init__.py,sha256=L_wVHAoQSMcnZaz-8vhGir9itE7RGq7jqSqTN6Uya1A,58613
+devduck/__main__.py,sha256=aeF2RR4k7lzSR2X1QKV9XQPCKhtsH0JYUv2etBBqmL0,145
+devduck/_version.py,sha256=5zTqm8rgXsWYBpB2M3Zw_K1D-aV8wP7NsBLrmMKkrAQ,704
+devduck/test_redduck.py,sha256=nqRchR7d54jWGx7JN5tji2ZV4Ek4L9s-P7hp0mKjA0Y,1773
+devduck/tools/__init__.py,sha256=mu3V4jL2ACN4f-pnUID_A2p6o3Yc_-V_y9071PduCR0,177
+devduck/tools/create_subagent.py,sha256=UzRz9BmU4PbTveZROEpZ311aH-u-i6x89gttu-CniAE,24687
+devduck/tools/install_tools.py,sha256=wm_67b9IfY-2wRuWgxuEKhaSIV5vNfbGmZL3G9dGi2A,10348
+devduck/tools/mcp_server.py,sha256=oyF1gb7K-OlxyJLUO3L-vNo2ajKzIrcnT1crwKMOkhU,20118
+devduck/tools/store_in_kb.py,sha256=-JM-oRQKR3FBubKHFHmXRnZSvi9dVgHxG0lismMgG2k,6861
+devduck/tools/tcp.py,sha256=HkJ_j1t7hsPMxNL51bYHvPkHoTfro9Nov6vClwvwkEk,21943
+devduck/tools/use_github.py,sha256=nr3JSGk48mKUobpgW__2gu6lFyUj93a1XRs3I6vH8W4,13682
+devduck/tools/websocket.py,sha256=lRJZt813iHorVr5UI66Lq-lmaFuLYAfpodeV2gtda7k,16635
+devduck-0.3.0.dist-info/licenses/LICENSE,sha256=CVGEiNh6cW1mgAKW83Q0P4xrQEXvqc6W-rb789W_IHM,1060
+devduck-0.3.0.dist-info/METADATA,sha256=pg0OIugkyVKbHA39NYYBJxr0MRVunCI9-XtwWr9Pcn4,4243
+devduck-0.3.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+devduck-0.3.0.dist-info/entry_points.txt,sha256=BAMQaIg_BLZQOTk12bT7hy1dE9oGPLt-_dTbI4cnBnQ,40
+devduck-0.3.0.dist-info/top_level.txt,sha256=ySXWlVronp8xHYfQ_Hdfr463e0EnbWuqyuxs94EU7yk,8
+devduck-0.3.0.dist-info/RECORD,,

{devduck-0.1.1766644714.dist-info → devduck-0.3.0.dist-info}/entry_points.txt

@@ -1,3 +1,2 @@
 [console_scripts]
-dev = devduck:cli
 devduck = devduck:cli

devduck-0.3.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 maxs
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

devduck/agentcore_handler.py

@@ -1,76 +0,0 @@
-#!/usr/bin/env python3
-"""DevDuck AgentCore Handler"""
-import json
-import os
-import threading
-from bedrock_agentcore.runtime import BedrockAgentCoreApp
-
-# Configure for AgentCore deployment
-os.environ["DEVDUCK_AUTO_START_SERVERS"] = "false"
-os.environ["MODEL_PROVIDER"] = "bedrock"
-
-from devduck import devduck
-
-app = BedrockAgentCoreApp()
-
-
-@app.entrypoint
-async def invoke(payload, context):
-    """AgentCore entrypoint - streaming by default with async generator"""
-    mode = payload.get("mode", "streaming")  # streaming (default), sync, async
-
-    query = payload.get("prompt", payload.get("text", ""))
-    if not query:
-        yield {"error": "No query provided"}
-        return
-
-    print(f"Mode: {mode}, Query: {query}")
-
-    agent = devduck.agent
-
-    if mode == "sync":
-        # Sync mode - return result directly (blocking)
-        try:
-            result = agent(query)
-            yield {"statusCode": 200, "response": str(result)}
-        except Exception as e:
-            print(f"Error in sync: {str(e)}")
-            yield {"statusCode": 500, "error": str(e)}
-
-    elif mode == "async":
-        # Async mode - fire and forget in background thread
-        task_id = app.add_async_task("devduck_processing", payload)
-        thread = threading.Thread(
-            target=lambda: _run_in_thread(agent, query, task_id), daemon=True
-        )
-        thread.start()
-        yield {"statusCode": 200, "task_id": task_id}
-
-    else:
-        # Streaming mode (default) - stream events as they happen
-        try:
-            stream = agent.stream_async(query)
-            async for event in stream:
-                print(event)
-                yield event
-        except Exception as e:
-            print(f"Error in streaming: {str(e)}")
-            yield {"error": str(e)}
-
-
-def _run_in_thread(agent, query, task_id):
-    """Run agent in background thread for async mode"""
-    try:
-        result = agent(query)
-        print(f"DevDuck result: {result}")
-        app.complete_async_task(task_id)
-    except Exception as e:
-        print(f"Error in async thread: {str(e)}")
-        try:
-            app.complete_async_task(task_id)
-        except:
-            pass
-
-
-if __name__ == "__main__":
-    app.run()