devduck 1.1.0__py3-none-any.whl → 1.1.4__py3-none-any.whl

devduck/__init__.py

@@ -3,19 +3,31 @@
 🦆 devduck - extreme minimalist self-adapting agent
 one file. self-healing. runtime dependencies. adaptive.
 """
+import os
 import sys
 import subprocess
-import os
+import threading
 import platform
 import socket
 import logging
 import tempfile
 import time
 import warnings
+import json
 from pathlib import Path
 from datetime import datetime
 from typing import Dict, Any
 from logging.handlers import RotatingFileHandler
+from strands import Agent, tool
+
+# Import system prompt helper for loading prompts from files
+try:
+    from devduck.tools.system_prompt import _get_system_prompt
+except ImportError:
+    # Fallback if tools module not available yet
+    def _get_system_prompt(repository=None, variable_name="SYSTEM_PROMPT"):
+        return os.getenv(variable_name, "")
+
 
 warnings.filterwarnings("ignore", message=".*pkg_resources is deprecated.*")
 warnings.filterwarnings("ignore", message=".*cache_prompt is deprecated.*")
@@ -594,7 +606,7 @@ class DevDuck:
                 servers = {
                     "tcp": {
                         "port": int(os.getenv("DEVDUCK_TCP_PORT", "9999")),
-                        "enabled": os.getenv("DEVDUCK_ENABLE_TCP", "true").lower()
+                        "enabled": os.getenv("DEVDUCK_ENABLE_TCP", "false").lower()
                         == "true",
                     },
                     "ws": {
@@ -604,25 +616,93 @@ class DevDuck:
                     },
                     "mcp": {
                         "port": int(os.getenv("DEVDUCK_MCP_PORT", "8000")),
-                        "enabled": os.getenv("DEVDUCK_ENABLE_MCP", "true").lower()
+                        "enabled": os.getenv("DEVDUCK_ENABLE_MCP", "false").lower()
                         == "true",
                     },
                     "ipc": {
                         "socket_path": os.getenv(
                             "DEVDUCK_IPC_SOCKET", "/tmp/devduck_main.sock"
                         ),
-                        "enabled": os.getenv("DEVDUCK_ENABLE_IPC", "true").lower()
+                        "enabled": os.getenv("DEVDUCK_ENABLE_IPC", "false").lower()
                         == "true",
                     },
                 }
 
-            self.servers = servers
+            # Show server configuration status
+            enabled_servers = []
+            disabled_servers = []
+            for server_name, config in servers.items():
+                if config.get("enabled", False):
+                    if "port" in config:
+                        enabled_servers.append(
+                            f"{server_name.upper()}:{config['port']}"
+                        )
+                    else:
+                        enabled_servers.append(server_name.upper())
+                else:
+                    disabled_servers.append(server_name.upper())
 
-            from strands import Agent, tool
+            logger.debug(
+                f"🦆 Server config: {', '.join(enabled_servers) if enabled_servers else 'none enabled'}"
+            )
+            if disabled_servers:
+                logger.debug(f"🦆 Disabled: {', '.join(disabled_servers)}")
+
+            self.servers = servers
 
             # Load tools with flexible configuration
-            # Default tool config - user can override with DEVDUCK_TOOLS env var
-            default_tools = "devduck.tools:system_prompt,store_in_kb,ipc,tcp,websocket,mcp_server,state_manager,tray,ambient,agentcore_config,agentcore_invoke,agentcore_logs,agentcore_agents,install_tools,create_subagent,use_github;strands_tools:shell,editor,file_read,file_write,image_reader,load_tool,retrieve,calculator,use_agent,environment,mcp_client,speak,slack;strands_fun_tools:listen,cursor,clipboard,screen_reader,bluetooth,yolo_vision"
+            # Default tool config
+            # Agent can load additional tools on-demand via fetch_github_tool
+
+            # 🔧 Available DevDuck Tools (load on-demand):
+            # - system_prompt: https://github.com/cagataycali/devduck/blob/main/devduck/tools/system_prompt.py
+            # - store_in_kb: https://github.com/cagataycali/devduck/blob/main/devduck/tools/store_in_kb.py
+            # - ipc: https://github.com/cagataycali/devduck/blob/main/devduck/tools/ipc.py
+            # - tcp: https://github.com/cagataycali/devduck/blob/main/devduck/tools/tcp.py
+            # - websocket: https://github.com/cagataycali/devduck/blob/main/devduck/tools/websocket.py
+            # - mcp_server: https://github.com/cagataycali/devduck/blob/main/devduck/tools/mcp_server.py
+            # - scraper: https://github.com/cagataycali/devduck/blob/main/devduck/tools/scraper.py
+            # - tray: https://github.com/cagataycali/devduck/blob/main/devduck/tools/tray.py
+            # - ambient: https://github.com/cagataycali/devduck/blob/main/devduck/tools/ambient.py
+            # - agentcore_config: https://github.com/cagataycali/devduck/blob/main/devduck/tools/agentcore_config.py
+            # - agentcore_invoke: https://github.com/cagataycali/devduck/blob/main/devduck/tools/agentcore_invoke.py
+            # - agentcore_logs: https://github.com/cagataycali/devduck/blob/main/devduck/tools/agentcore_logs.py
+            # - agentcore_agents: https://github.com/cagataycali/devduck/blob/main/devduck/tools/agentcore_agents.py
+            # - create_subagent: https://github.com/cagataycali/devduck/blob/main/devduck/tools/create_subagent.py
+            # - use_github: https://github.com/cagataycali/devduck/blob/main/devduck/tools/use_github.py
+            # - speech_to_speech: https://github.com/cagataycali/devduck/blob/main/devduck/tools/speech_to_speech.py
+            # - state_manager: https://github.com/cagataycali/devduck/blob/main/devduck/tools/state_manager.py
+
+            # 📦 Strands Tools
+            # - editor, file_read, file_write, image_reader, load_tool, retrieve
+            # - calculator, use_agent, environment, mcp_client, speak, slack
+
+            # 🎮 Strands Fun Tools
+            # - listen, cursor, clipboard, screen_reader, bluetooth, yolo_vision
+
+            # 🔍 Strands Google
+            # - use_google, google_auth
+
+            # 🔧 Auto-append server tools based on enabled servers
+            server_tools_needed = []
+            if servers.get("tcp", {}).get("enabled", False):
+                server_tools_needed.append("tcp")
+            if servers.get("ws", {}).get("enabled", True):
+                server_tools_needed.append("websocket")
+            if servers.get("mcp", {}).get("enabled", False):
+                server_tools_needed.append("mcp_server")
+            if servers.get("ipc", {}).get("enabled", False):
+                server_tools_needed.append("ipc")
+
+            # Append to default tools if any server tools are needed
+            if server_tools_needed:
+                server_tools_str = ",".join(server_tools_needed)
+                default_tools = f"devduck.tools:system_prompt,fetch_github_tool,{server_tools_str};strands_tools:shell"
+                logger.info(f"Auto-added server tools: {server_tools_str}")
+            else:
+                default_tools = (
+                    "devduck.tools:system_prompt,fetch_github_tool;strands_tools:shell"
+                )
 
             tools_config = os.getenv("DEVDUCK_TOOLS", default_tools)
             logger.info(f"Loading tools from config: {tools_config}")
@@ -776,8 +856,6 @@ class DevDuck:
         Returns:
             List of MCPClient instances ready for direct use in Agent
         """
-        import json
-
         mcp_servers_json = os.getenv("MCP_SERVERS")
         if not mcp_servers_json:
             logger.debug("No MCP_SERVERS environment variable found")
@@ -1145,7 +1223,7 @@ When you learn something valuable during conversations:
 - Communication: **MINIMAL WORDS**
 - Efficiency: **Speed is paramount**
 
-{os.getenv('SYSTEM_PROMPT', '')}"""
+{_get_system_prompt()}"""
 
     def _self_heal(self, error):
         """Attempt self-healing when errors occur"""
@@ -1192,7 +1270,6 @@ When you learn something valuable during conversations:
 
     def _is_socket_available(self, socket_path):
         """Check if a Unix socket is available"""
-        import os
 
         # If socket file doesn't exist, it's available
         if not os.path.exists(socket_path):
@@ -1430,11 +1507,11 @@ When you learn something valuable during conversations:
     def restart(self):
         """Restart the agent"""
         print("\n🦆 Restarting...")
+        logger.debug("\n🦆 Restarting...")
         self.__init__()
 
     def _start_file_watcher(self):
         """Start background file watcher for auto hot-reload"""
-        import threading
 
         logger.info("Starting file watcher for hot-reload")
         # Get the path to this file
@@ -1534,6 +1611,7 @@ When you learn something valuable during conversations:
                 self._watcher_running = False
 
             print("\n🦆 Restarting process with fresh code...")
+            logger.debug("\n🦆 Restarting process with fresh code...")
 
             # Restart the entire Python process
             # This ensures all code is freshly loaded
@@ -1677,7 +1755,7 @@ def interactive():
     print(f"📝 Logs: {LOG_DIR}")
     print("Type 'exit', 'quit', or 'q' to quit.")
     print("Prefix with ! to run shell commands (e.g., ! ls -la)")
-    print("-" * 50)
+    print("\n\n")
     logger.info("Interactive mode started")
 
     # Set up prompt_toolkit with history
@@ -1705,7 +1783,6 @@ def interactive():
                 auto_suggest=AutoSuggestFromHistory(),
                 completer=completer,
                 complete_while_typing=True,
-                mouse_support=False,  # breaks scrolling when enabled
             )
 
             # Reset interrupt count on successful prompt
@@ -1733,6 +1810,10 @@ def interactive():
                         )
                         devduck._agent_executing = False
 
+                        # Reset terminal to fix rendering issues after command output
+                        print("\r", end="", flush=True)
+                        sys.stdout.flush()
+
                         # Append shell command to history
                         append_to_shell_history(q, result["content"][0]["text"])
 
@@ -1747,6 +1828,9 @@ def interactive():
                 except Exception as e:
                     devduck._agent_executing = False  # Reset on error
                     print(f"🦆 Shell command error: {e}")
+                    # Reset terminal on error too
+                    print("\r", end="", flush=True)
+                    sys.stdout.flush()
                 continue
 
             # Execute the agent with user input

devduck/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '1.1.0'
-__version_tuple__ = version_tuple = (1, 1, 0)
+__version__ = version = '1.1.4'
+__version_tuple__ = version_tuple = (1, 1, 4)
 
 __commit_id__ = commit_id = None

devduck/tools/__init__.py

@@ -1,55 +1,47 @@
-"""DevDuck tools package."""
+"""
+DevDuck Tools Package
 
-from .tcp import tcp
-from .mcp_server import mcp_server
-from .install_tools import install_tools
-from .tray import tray
+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 .websocket import websocket
-from .ipc import ipc
-from .use_github import use_github
 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 .state_manager import state_manager
-
-# AgentCore tools (conditionally available)
-try:
-    from .agentcore_config import agentcore_config
-    from .agentcore_invoke import agentcore_invoke
-    from .agentcore_logs import agentcore_logs
-    from .agentcore_agents import agentcore_agents
+from .tcp import tcp
+from .tray import tray
+from .use_github import use_github
+from .websocket import websocket
 
-    __all__ = [
-        "tcp",
-        "websocket",
-        "ipc",
-        "mcp_server",
-        "install_tools",
-        "use_github",
-        "create_subagent",
-        "store_in_kb",
-        "system_prompt",
-        "state_manager",
-        "tray",
-        "ambient",
-        "agentcore_config",
-        "agentcore_invoke",
-        "agentcore_logs",
-        "agentcore_agents",
-    ]
-except ImportError:
-    __all__ = [
-        "tcp",
-        "websocket",
-        "ipc",
-        "mcp_server",
-        "install_tools",
-        "use_github",
-        "create_subagent",
-        "store_in_kb",
-        "system_prompt",
-        "state_manager",
-        "tray",
-        "ambient",
-    ]
+__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",
+]

devduck/tools/fetch_github_tool.py

@@ -0,0 +1,201 @@
+"""GitHub Tool Fetcher for Strands Agent.
+
+This tool fetches Python tool files from GitHub repositories and loads them
+as available tools in the current Strands agent. It combines HTTP fetching
+with the load_tool functionality to enable dynamic tool loading from remote
+GitHub repositories.
+
+Usage with Strands Agents:
+python
+from strands import Agent
+from tools.fetch_github_tool import fetch_github_tool
+
+agent = Agent(tools=[fetch_github_tool])
+
+# Fetch and load a tool from GitHub
+agent.tool.fetch_github_tool(
+    github_url="https://github.com/owner/repo/blob/main/tools/my_tool.py",
+    tool_name="my_tool"
+)
+
+# Now you can use the fetched tool
+agent.tool.my_tool(param1="value")
+
+
+Supported GitHub URL formats:
+- https://github.com/owner/repo/blob/branch/path/to/file.py
+- https://github.com/owner/repo/tree/branch/path/to/file.py
+- https://raw.githubusercontent.com/owner/repo/branch/path/to/file.py
+"""
+
+import os
+import re
+from pathlib import Path
+from typing import Any
+
+import requests
+from strands import tool
+
+
+def parse_github_url(github_url: str) -> dict[str, str]:
+    """Parse GitHub URL to extract repository information.
+
+    Args:
+        github_url: GitHub URL to the file
+
+    Returns:
+        Dictionary with owner, repo, branch, and file_path
+
+    Raises:
+        ValueError: If URL format is not supported
+    """
+    # Handle raw.githubusercontent.com URLs
+    raw_pattern = r"https://raw\.githubusercontent\.com/([^/]+)/([^/]+)/([^/]+)/(.+)"
+    raw_match = re.match(raw_pattern, github_url)
+
+    if raw_match:
+        owner, repo, branch, file_path = raw_match.groups()
+        return {"owner": owner, "repo": repo, "branch": branch, "file_path": file_path}
+
+    # Handle github.com/owner/repo/blob/branch/path URLs
+    blob_pattern = r"https://github\.com/([^/]+)/([^/]+)/(?:blob|tree)/([^/]+)/(.+)"
+    blob_match = re.match(blob_pattern, github_url)
+
+    if blob_match:
+        owner, repo, branch, file_path = blob_match.groups()
+        return {"owner": owner, "repo": repo, "branch": branch, "file_path": file_path}
+
+    raise ValueError(f"Unsupported GitHub URL format: {github_url}")
+
+
+def build_raw_url(owner: str, repo: str, branch: str, file_path: str) -> str:
+    """Build GitHub raw content URL.
+
+    Args:
+        owner: Repository owner
+        repo: Repository name
+        branch: Branch name
+        file_path: Path to file in repository
+
+    Returns:
+        Raw GitHub URL for the file
+    """
+    return f"https://raw.githubusercontent.com/{owner}/{repo}/{branch}/{file_path}"
+
+
+@tool
+def fetch_github_tool(
+    github_url: str,
+    tool_name: str | None = None,
+    local_dir: str = "./github_tools",
+    agent: Any = None,
+) -> dict[str, Any]:
+    """Fetch a Python tool file from GitHub and load it as a Strands tool.
+
+    This tool downloads Python files from GitHub repositories, saves them locally,
+    and registers them as available tools in the current Strands agent. It supports
+    various GitHub URL formats and automatically handles the conversion to raw content URLs.
+
+    Args:
+        github_url: GitHub URL to the Python tool file. Supports formats like:
+            - https://github.com/owner/repo/blob/main/tools/my_tool.py
+            - https://github.com/owner/repo/tree/main/tools/my_tool.py
+            - https://raw.githubusercontent.com/owner/repo/main/tools/my_tool.py
+        tool_name: Name to register the tool under. If not provided, will extract
+            from the filename (e.g., "my_tool.py" becomes "my_tool")
+        local_dir: Local directory to save the fetched tool file. Defaults to "./github_tools"
+        agent: Agent instance (automatically provided by Strands)
+
+    Returns:
+        Dict containing status and response content:
+        {
+            "status": "success|error",
+            "content": [{"text": "Response message"}]
+        }
+
+    Examples:
+        # Fetch a tool from GitHub and load it
+        agent.tool.fetch_github_tool(
+            github_url="https://github.com/cagataycali/my-tools/blob/main/weather_tool.py",
+            tool_name="weather"
+        )
+
+        # Tool name can be auto-detected from filename
+        agent.tool.fetch_github_tool(
+            github_url="https://github.com/cagataycali/my-tools/blob/main/calculator.py"
+        )
+    """
+    try:
+        # Parse the GitHub URL
+        try:
+            url_info = parse_github_url(github_url)
+        except ValueError as e:
+            return {"status": "error", "content": [{"text": f"❌ {e!s}"}]}
+
+        # Extract tool name from filename if not provided
+        if not tool_name:
+            filename = os.path.basename(url_info["file_path"])
+            tool_name = os.path.splitext(filename)[0]
+
+        # Check if it's a Python file first (before making HTTP request)
+        if not url_info["file_path"].endswith(".py"):
+            return {
+                "status": "error",
+                "content": [
+                    {
+                        "text": f"❌ File must be a Python file (.py), got: {url_info['file_path']}"
+                    }
+                ],
+            }
+
+        # Build raw GitHub URL
+        raw_url = build_raw_url(
+            url_info["owner"],
+            url_info["repo"],
+            url_info["branch"],
+            url_info["file_path"],
+        )
+
+        # Create local directory if it doesn't exist
+        local_path = Path(local_dir)
+        local_path.mkdir(parents=True, exist_ok=True)
+
+        # Download the file
+        response = requests.get(raw_url, timeout=30)
+        response.raise_for_status()
+        # Save the file locally
+        local_file_path = local_path / f"{tool_name}.py"
+        with open(local_file_path, "w", encoding="utf-8") as f:
+            f.write(response.text)
+
+        # Load the tool using load_tool functionality
+        if agent and hasattr(agent, "tool_registry"):
+            agent.tool_registry.load_tool_from_filepath(
+                tool_name=tool_name, tool_path=str(local_file_path)
+            )
+
+            success_message = f"""✅ Successfully fetched and loaded GitHub tool!
+
+📂 **Source:** {github_url}
+🏷️  **Tool Name:** {tool_name}
+💾 **Local Path:** {local_file_path}
+🔧 **Status:** Ready to use
+
+You can now use the tool with: agent.tool.{tool_name}(...)"""
+
+            return {"status": "success", "content": [{"text": success_message}]}
+        else:
+            return {
+                "status": "error",
+                "content": [
+                    {"text": "❌ Agent instance not available for tool registration"}
+                ],
+            }
+
+    except requests.RequestException as e:
+        return {
+            "status": "error",
+            "content": [{"text": f"❌ Failed to download file from GitHub: {e!s}"}],
+        }
+    except Exception as e:
+        return {"status": "error", "content": [{"text": f"❌ Unexpected error: {e!s}"}]}