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

devduck/tools/agentcore_logs.py

@@ -1,320 +0,0 @@
-"""AgentCore Logs Tool - View CloudWatch logs from deployed DevDuck instances."""
-
-from datetime import datetime, timedelta
-from typing import Any, Dict, Optional
-from strands import tool
-
-
-@tool
-def agentcore_logs(
-    action: str = "recent",
-    agent_name: str = "devduck",
-    limit: int = 50,
-    start_time: Optional[str] = None,
-    end_time: Optional[str] = None,
-    filter_pattern: Optional[str] = None,
-    log_stream_name: Optional[str] = None,
-    endpoint: str = "DEFAULT",
-    region: str = "us-west-2",
-) -> Dict[str, Any]:
-    """View CloudWatch logs from deployed DevDuck instances on AgentCore.
-
-    Args:
-        action: Log operation (recent, streams, search, tail)
-        agent_name: Name of deployed agent (default: devduck)
-        limit: Max events/streams to return (default: 50)
-        start_time: Start time in ISO format (default: last hour)
-        end_time: End time in ISO format (default: now)
-        filter_pattern: CloudWatch filter pattern for search
-        log_stream_name: Specific stream to tail
-        endpoint: Endpoint qualifier (default: DEFAULT)
-        region: AWS region (default: us-west-2)
-
-    Returns:
-        Dict with status and log content
-
-    Examples:
-        # Recent logs
-        agentcore_logs(agent_name="devduck")
-
-        # Search for errors
-        agentcore_logs(
-            action="search",
-            filter_pattern="ERROR"
-        )
-
-        # List streams
-        agentcore_logs(action="streams")
-
-        # Tail specific stream
-        agentcore_logs(
-            action="tail",
-            log_stream_name="2025/11/16/[runtime-logs]session-abc"
-        )
-    """
-    try:
-        import boto3
-        import yaml
-        from pathlib import Path
-        from botocore.exceptions import ClientError
-
-        # Load config to get agent ID
-        devduck_dir = Path(__file__).parent.parent
-        config_path = devduck_dir / ".bedrock_agentcore.yaml"
-
-        if not config_path.exists():
-            return {
-                "status": "error",
-                "content": [
-                    {"text": "Agent not configured. Run agentcore_launch() first."}
-                ],
-            }
-
-        with open(config_path) as f:
-            config = yaml.safe_load(f)
-
-        # Get agent ID
-        if "agents" not in config or agent_name not in config["agents"]:
-            return {
-                "status": "error",
-                "content": [{"text": f"Agent '{agent_name}' not found in config"}],
-            }
-
-        agent_id = (
-            config["agents"][agent_name].get("bedrock_agentcore", {}).get("agent_id")
-        )
-
-        if not agent_id:
-            return {
-                "status": "error",
-                "content": [
-                    {
-                        "text": f"Agent '{agent_name}' not deployed. Run agentcore_launch()."
-                    }
-                ],
-            }
-
-        # CloudWatch client
-        logs_client = boto3.client("logs", region_name=region)
-
-        # Build log group name
-        log_group_name = f"/aws/bedrock-agentcore/runtimes/{agent_id}-{endpoint}"
-
-        # Route to appropriate handler
-        if action == "recent":
-            return _get_recent_logs(
-                logs_client, log_group_name, limit, start_time, end_time, filter_pattern
-            )
-        elif action == "streams":
-            return _list_log_streams(logs_client, log_group_name, limit)
-        elif action == "search":
-            if not filter_pattern:
-                return {
-                    "status": "error",
-                    "content": [{"text": "filter_pattern required for search"}],
-                }
-            return _search_logs(
-                logs_client, log_group_name, filter_pattern, limit, start_time, end_time
-            )
-        elif action == "tail":
-            if not log_stream_name:
-                log_stream_name = _get_latest_stream(logs_client, log_group_name)
-                if not log_stream_name:
-                    return {
-                        "status": "error",
-                        "content": [{"text": "No log streams found"}],
-                    }
-            return _tail_logs(logs_client, log_group_name, log_stream_name, limit)
-        else:
-            return {
-                "status": "error",
-                "content": [{"text": f"Unknown action: {action}"}],
-            }
-
-    except ClientError as e:
-        error_code = e.response["Error"]["Code"]
-        if error_code == "ResourceNotFoundException":
-            return {
-                "status": "error",
-                "content": [
-                    {"text": f"Log group not found: {log_group_name}"},
-                    {"text": "Agent may not be deployed or hasn't logged yet"},
-                ],
-            }
-        return {"status": "error", "content": [{"text": f"AWS Error: {str(e)}"}]}
-    except Exception as e:
-        return {"status": "error", "content": [{"text": f"Error: {str(e)}"}]}
-
-
-def _get_recent_logs(
-    client,
-    log_group_name: str,
-    limit: int,
-    start_time: Optional[str],
-    end_time: Optional[str],
-    filter_pattern: Optional[str],
-) -> Dict[str, Any]:
-    """Get recent log events."""
-    params = {
-        "logGroupName": log_group_name,
-        "limit": limit,
-        "interleaved": True,
-    }
-
-    if start_time:
-        start_dt = datetime.fromisoformat(start_time.replace("Z", "+00:00"))
-        params["startTime"] = int(start_dt.timestamp() * 1000)
-    else:
-        # Default: last 5 minutes for truly recent logs
-        params["startTime"] = int(
-            (datetime.now() - timedelta(minutes=5)).timestamp() * 1000
-        )
-
-    if end_time:
-        end_dt = datetime.fromisoformat(end_time.replace("Z", "+00:00"))
-        params["endTime"] = int(end_dt.timestamp() * 1000)
-
-    if filter_pattern:
-        params["filterPattern"] = filter_pattern
-
-    response = client.filter_log_events(**params)
-    events = response.get("events", [])
-
-    if not events:
-        return {
-            "status": "success",
-            "content": [{"text": "No log events found in last 5 minutes"}],
-        }
-
-    # Sort by timestamp descending (most recent first)
-    events.sort(key=lambda e: e["timestamp"], reverse=True)
-
-    # Format logs
-    log_lines = []
-    for event in events:
-        timestamp = datetime.fromtimestamp(event["timestamp"] / 1000).strftime(
-            "%Y-%m-%d %H:%M:%S"
-        )
-        message = event["message"].rstrip()
-        log_lines.append(f"[{timestamp}] {message}")
-
-    return {
-        "status": "success",
-        "content": [
-            {"text": f"Found {len(events)} log events:\n"},
-            {"text": "\n".join(log_lines)},
-        ],
-    }
-
-
-def _list_log_streams(client, log_group_name: str, limit: int) -> Dict[str, Any]:
-    """List log streams."""
-    response = client.describe_log_streams(
-        logGroupName=log_group_name,
-        orderBy="LastEventTime",
-        descending=True,
-        limit=limit,
-    )
-
-    streams = response.get("logStreams", [])
-
-    if not streams:
-        return {"status": "success", "content": [{"text": "No log streams found"}]}
-
-    stream_lines = [f"Found {len(streams)} log streams:\n"]
-    for stream in streams:
-        stream_name = stream["logStreamName"]
-        last_event = datetime.fromtimestamp(
-            stream.get("lastEventTimestamp", 0) / 1000
-        ).strftime("%Y-%m-%d %H:%M:%S")
-        stream_lines.append(f"• {stream_name} (last: {last_event})")
-
-    return {"status": "success", "content": [{"text": "\n".join(stream_lines)}]}
-
-
-def _search_logs(
-    client,
-    log_group_name: str,
-    filter_pattern: str,
-    limit: int,
-    start_time: Optional[str],
-    end_time: Optional[str],
-) -> Dict[str, Any]:
-    """Search logs with pattern."""
-    params = {
-        "logGroupName": log_group_name,
-        "filterPattern": filter_pattern,
-        "limit": limit,
-        "interleaved": True,
-    }
-
-    if start_time:
-        start_dt = datetime.fromisoformat(start_time.replace("Z", "+00:00"))
-        params["startTime"] = int(start_dt.timestamp() * 1000)
-    else:
-        params["startTime"] = int(
-            (datetime.now() - timedelta(hours=24)).timestamp() * 1000
-        )
-
-    if end_time:
-        end_dt = datetime.fromisoformat(end_time.replace("Z", "+00:00"))
-        params["endTime"] = int(end_dt.timestamp() * 1000)
-
-    response = client.filter_log_events(**params)
-    events = response.get("events", [])
-
-    if not events:
-        return {
-            "status": "success",
-            "content": [{"text": f"No matches for pattern: {filter_pattern}"}],
-        }
-
-    log_lines = [f"Found {len(events)} matches:\n"]
-    for event in events:
-        timestamp = datetime.fromtimestamp(event["timestamp"] / 1000).strftime(
-            "%Y-%m-%d %H:%M:%S"
-        )
-        message = event["message"].rstrip()
-        log_lines.append(f"[{timestamp}] {message}")
-
-    return {"status": "success", "content": [{"text": "\n".join(log_lines)}]}
-
-
-def _tail_logs(
-    client, log_group_name: str, log_stream_name: str, limit: int
-) -> Dict[str, Any]:
-    """Tail specific log stream."""
-    response = client.get_log_events(
-        logGroupName=log_group_name,
-        logStreamName=log_stream_name,
-        limit=limit,
-        startFromHead=False,
-    )
-
-    events = response.get("events", [])
-
-    if not events:
-        return {
-            "status": "success",
-            "content": [{"text": f"No events in stream: {log_stream_name}"}],
-        }
-
-    log_lines = [f"Latest {len(events)} events:\n"]
-    for event in events:
-        timestamp = datetime.fromtimestamp(event["timestamp"] / 1000).strftime(
-            "%Y-%m-%d %H:%M:%S"
-        )
-        message = event["message"].rstrip()
-        log_lines.append(f"[{timestamp}] {message}")
-
-    return {"status": "success", "content": [{"text": "\n".join(log_lines)}]}
-
-
-def _get_latest_stream(client, log_group_name: str) -> Optional[str]:
-    """Get latest log stream."""
-    response = client.describe_log_streams(
-        logGroupName=log_group_name, orderBy="LastEventTime", descending=True, limit=1
-    )
-
-    streams = response.get("logStreams", [])
-    return streams[0]["logStreamName"] if streams else None

devduck/tools/ambient.py

@@ -1,157 +0,0 @@
-"""
-Ambient input overlay control tool - integrated with devduck
-"""
-
-from strands import tool
-from typing import Dict, Any
-import subprocess
-import socket
-import json
-import tempfile
-import os
-import time
-import signal
-import sys
-from pathlib import Path
-
-# Global state
-_ambient_process = None
-
-
-def _send_command(command: Dict) -> Dict:
-    """Send command to ambient input overlay"""
-    socket_path = os.path.join(tempfile.gettempdir(), "devduck_ambient.sock")
-
-    try:
-        client = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
-        client.settimeout(2.0)
-        client.connect(socket_path)
-        client.sendall(json.dumps(command).encode("utf-8"))
-
-        response_data = client.recv(4096)
-        client.close()
-
-        if not response_data:
-            return {"status": "error", "message": "Empty response"}
-
-        return json.loads(response_data.decode("utf-8"))
-    except socket.timeout:
-        return {"status": "error", "message": "Timeout"}
-    except Exception as e:
-        return {"status": "error", "message": str(e)}
-
-
-@tool
-def ambient(
-    action: str,
-    text: str = None,
-) -> Dict[str, Any]:
-    """Control ambient AI input overlay.
-
-    Args:
-        action: Action to perform
-            - "start": Start ambient overlay
-            - "stop": Stop overlay
-            - "show": Show overlay
-            - "hide": Hide overlay
-            - "status": Check if running
-            - "set_text": Pre-fill text
-        text: Text to pre-fill (for set_text action)
-
-    Returns:
-        Dict with status and content
-
-    Features:
-        🎨 Modern glassmorphism UI
-        ⚡ Blinking cursor with auto-focus
-        🌊 Real-time IPC streaming from devduck
-        📦 Structured message handling
-        ⌨️ ESC to hide, Enter to send
-    """
-    global _ambient_process
-
-    if action == "start":
-        if _ambient_process and _ambient_process.poll() is None:
-            return {"status": "success", "content": [{"text": "✓ Already running"}]}
-
-        # Get ambient script path (in same directory as this file)
-        tools_dir = Path(__file__).parent
-        ambient_script = tools_dir / "_ambient_input.py"
-
-        if not ambient_script.exists():
-            return {
-                "status": "error",
-                "content": [{"text": f"❌ Ambient script not found: {ambient_script}"}],
-            }
-
-        _ambient_process = subprocess.Popen(
-            [sys.executable, str(ambient_script)],
-            stdout=subprocess.DEVNULL,
-            stderr=subprocess.DEVNULL,
-        )
-
-        time.sleep(1.5)
-
-        return {
-            "status": "success",
-            "content": [
-                {"text": f"✓ Ambient overlay started (PID: {_ambient_process.pid})"}
-            ],
-        }
-
-    elif action == "stop":
-        if _ambient_process:
-            try:
-                os.kill(_ambient_process.pid, signal.SIGTERM)
-                _ambient_process.wait(timeout=3)
-            except:
-                pass
-            _ambient_process = None
-
-        return {"status": "success", "content": [{"text": "✓ Stopped"}]}
-
-    elif action == "status":
-        is_running = _ambient_process and _ambient_process.poll() is None
-        return {"status": "success", "content": [{"text": f"Running: {is_running}"}]}
-
-    elif action == "show":
-        result = _send_command({"action": "show"})
-        if result.get("status") == "success":
-            return {"status": "success", "content": [{"text": "✓ Overlay shown"}]}
-        else:
-            return {
-                "status": "error",
-                "content": [
-                    {"text": f"Failed: {result.get('message', 'Unknown error')}"}
-                ],
-            }
-
-    elif action == "hide":
-        result = _send_command({"action": "hide"})
-        if result.get("status") == "success":
-            return {"status": "success", "content": [{"text": "✓ Overlay hidden"}]}
-        else:
-            return {
-                "status": "error",
-                "content": [
-                    {"text": f"Failed: {result.get('message', 'Unknown error')}"}
-                ],
-            }
-
-    elif action == "set_text":
-        if not text:
-            return {"status": "error", "content": [{"text": "text parameter required"}]}
-
-        result = _send_command({"action": "set_text", "text": text})
-        if result.get("status") == "success":
-            return {"status": "success", "content": [{"text": f"✓ Text set: {text}"}]}
-        else:
-            return {
-                "status": "error",
-                "content": [
-                    {"text": f"Failed: {result.get('message', 'Unknown error')}"}
-                ],
-            }
-
-    else:
-        return {"status": "error", "content": [{"text": f"Unknown action: {action}"}]}

devduck/tools/fetch_github_tool.py

@@ -1,201 +0,0 @@
-"""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}"}]}