deepagents-cli 0.0.1__py3-none-any.whl

deepagents/__init__.py

@@ -0,0 +1,18 @@
+"""DeepAgents package."""
+
+from deepagents.graph import create_deep_agent
+from deepagents.middleware.filesystem import FilesystemMiddleware
+from deepagents.middleware.local_filesystem import LocalFilesystemMiddleware
+from deepagents.middleware.subagents import CompiledSubAgent, SubAgent, SubAgentMiddleware
+from deepagents.skills import load_skills, SkillDefinition
+
+__all__ = [
+    "CompiledSubAgent",
+    "FilesystemMiddleware",
+    "LocalFilesystemMiddleware",
+    "SkillDefinition",
+    "SubAgent",
+    "SubAgentMiddleware",
+    "create_deep_agent",
+    "load_skills",
+]

deepagents/cli.py

@@ -0,0 +1,582 @@
+#!/usr/bin/env python3
+import argparse
+import asyncio
+import os
+import subprocess
+import platform
+import requests
+from typing import Dict, Any, Union, Literal
+from pathlib import Path
+
+from tavily import TavilyClient
+from deepagents import create_deep_agent
+from langgraph.checkpoint.memory import InMemorySaver
+from langgraph.types import Command, Interrupt
+
+from rich.console import Console
+from rich.markdown import Markdown
+from rich.panel import Panel
+from rich.syntax import Syntax
+from rich.text import Text
+from rich.live import Live
+from rich.spinner import Spinner
+from rich.prompt import Prompt
+import shutil
+from rich import box
+
+import dotenv
+
+dotenv.load_dotenv()
+
+console = Console()
+
+tavily_client = TavilyClient(api_key=os.environ.get("TAVILY_API_KEY")) if os.environ.get("TAVILY_API_KEY") else None
+
+
+def http_request(
+    url: str,
+    method: str = "GET",
+    headers: Dict[str, str] = None,
+    data: Union[str, Dict] = None,
+    params: Dict[str, str] = None,
+    timeout: int = 30,
+) -> Dict[str, Any]:
+    """
+    Make HTTP requests to APIs and web services.
+
+    Args:
+        url: Target URL
+        method: HTTP method (GET, POST, PUT, DELETE, etc.)
+        headers: HTTP headers to include
+        data: Request body data (string or dict)
+        params: URL query parameters
+        timeout: Request timeout in seconds
+
+    Returns:
+        Dictionary with response data including status, headers, and content
+    """
+    try:
+        kwargs = {"url": url, "method": method.upper(), "timeout": timeout}
+
+        if headers:
+            kwargs["headers"] = headers
+        if params:
+            kwargs["params"] = params
+        if data:
+            if isinstance(data, dict):
+                kwargs["json"] = data
+            else:
+                kwargs["data"] = data
+
+        response = requests.request(**kwargs)
+
+        try:
+            content = response.json()
+        except:
+            content = response.text
+
+        return {
+            "success": response.status_code < 400,
+            "status_code": response.status_code,
+            "headers": dict(response.headers),
+            "content": content,
+            "url": response.url,
+        }
+
+    except requests.exceptions.Timeout:
+        return {
+            "success": False,
+            "status_code": 0,
+            "headers": {},
+            "content": f"Request timed out after {timeout} seconds",
+            "url": url,
+        }
+    except requests.exceptions.RequestException as e:
+        return {
+            "success": False,
+            "status_code": 0,
+            "headers": {},
+            "content": f"Request error: {str(e)}",
+            "url": url,
+        }
+    except Exception as e:
+        return {
+            "success": False,
+            "status_code": 0,
+            "headers": {},
+            "content": f"Error making request: {str(e)}",
+            "url": url,
+        }
+
+
+def web_search(
+    query: str,
+    max_results: int = 5,
+    topic: Literal["general", "news", "finance"] = "general",
+    include_raw_content: bool = False,
+):
+    """Search the web using Tavily for programming-related information."""
+    if tavily_client is None:
+        return {
+            "error": "Tavily API key not configured. Please set TAVILY_API_KEY environment variable.",
+            "query": query
+        }
+    
+    try:
+        search_docs = tavily_client.search(
+            query,
+            max_results=max_results,
+            include_raw_content=include_raw_content,
+            topic=topic,
+        )
+        return search_docs
+    except Exception as e:
+        return {
+            "error": f"Web search error: {str(e)}",
+            "query": query
+        }
+
+
+def get_default_coding_instructions(include_memory: bool = True) -> str:
+    """Get the default coding agent instructions.
+    
+    Args:
+        include_memory: If False, removes the Long-term Memory section from the prompt.
+    """
+    default_prompt_path = Path(__file__).parent / "default_agent_prompt.md"
+    prompt = default_prompt_path.read_text()
+    
+    if not include_memory:
+        # Remove the Long-term Memory section
+        lines = prompt.split('\n')
+        result_lines = []
+        skip = False
+        
+        for line in lines:
+            if line.strip() == "## Long-term Memory":
+                skip = True
+                continue
+            if skip and line.startswith('##'):
+                skip = False
+            if not skip:
+                result_lines.append(line)
+        
+        prompt = '\n'.join(result_lines).rstrip() + '\n'
+    
+    return prompt
+
+
+def get_coding_instructions(agent_name: str | None, long_term_memory: bool = False) -> str:
+    """Get the coding agent instructions from file or create default.
+    
+    If agent_name is None or long_term_memory is False, returns default instructions without memory features.
+    """
+    if agent_name is None or not long_term_memory:
+        return get_default_coding_instructions(include_memory=False)
+    
+    agent_dir = Path.home() / ".deepagents" / agent_name
+    agent_prompt_file = agent_dir / "agent.md"
+    
+    if agent_prompt_file.exists():
+        agent_memory_content = agent_prompt_file.read_text()
+    else:
+        agent_dir.mkdir(parents=True, exist_ok=True)
+        default_prompt = get_default_coding_instructions(include_memory=True)
+        agent_prompt_file.write_text(default_prompt)
+        agent_memory_content = default_prompt
+    
+    return f"<agent_memory>\n{agent_memory_content}\n</agent_memory>"
+
+
+config = {"recursion_limit": 1000}
+
+# Constants for display truncation
+MAX_ARG_LENGTH = 200
+MAX_RESULT_LENGTH = 200
+
+
+def truncate_value(value: str, max_length: int = MAX_ARG_LENGTH) -> str:
+    """Truncate a string value if it exceeds max_length."""
+    if len(value) > max_length:
+        return value[:max_length] + "..."
+    return value
+
+
+def format_tool_args(tool_input: dict) -> str:
+    """Format tool arguments for display, truncating long values."""
+    if not tool_input:
+        return ""
+    
+    args_parts = []
+    for key, value in tool_input.items():
+        value_str = str(value)
+        value_str = truncate_value(value_str)
+        args_parts.append(f"{key}={value_str}")
+    
+    return ", ".join(args_parts)
+
+
+def display_tool_call(tool_name: str, tool_input: dict):
+    """Display a tool call with arguments, truncating long values."""
+    
+    tool_icons = {
+        "read_file": "📖",
+        "write_file": "✏️",
+        "edit_file": "✂️",
+        "ls": "📁",
+        "glob": "🔍",
+        "grep": "🔎",
+        "shell": "⚡",
+        "web_search": "🌐",
+        "http_request": "🌍",
+        "task": "🤖",
+        "write_todos": "📋",
+    }
+    
+    icon = tool_icons.get(tool_name, "🔧")
+    args_str = format_tool_args(tool_input)
+    
+    # Display: icon tool_name(args)
+    if args_str:
+        console.print(f"[dim]{icon} {tool_name}({args_str})[/dim]")
+    else:
+        console.print(f"[dim]{icon} {tool_name}()[/dim]")
+
+
+def display_text_content(text: str):
+    """Display text content with markdown rendering."""
+    if text.strip():
+        if "```" in text or "#" in text or "**" in text:
+            md = Markdown(text)
+            console.print(md)
+        else:
+            console.print(text, style="white")
+
+
+def extract_and_display_content(message_content):
+    """Extract content from agent messages and display with rich formatting."""
+    if isinstance(message_content, str):
+        display_text_content(message_content)
+        return
+
+    if isinstance(message_content, list):
+        for block in message_content:
+            if isinstance(block, dict):
+                if block.get("type") == "text" and "text" in block:
+                    display_text_content(block["text"])
+                elif block.get("type") == "tool_use":
+                    tool_name = block.get("name", "unknown_tool")
+                    tool_input = block.get("input", {})
+                    display_tool_call(tool_name, tool_input)
+                # Skip tool_result blocks - they're just noise
+                elif block.get("type") == "tool_result":
+                    pass  # Don't display tool results
+
+
+def execute_task(user_input: str, agent, agent_name: str | None):
+    """Execute any task by passing it directly to the AI agent."""
+    console.print()
+    
+    config = {"configurable": {"thread_id": "main", "agent_name": agent_name}} if agent_name else {"configurable": {"thread_id": "main"}}
+    
+    for _, chunk in agent.stream(
+        {"messages": [{"role": "user", "content": user_input}]},
+        stream_mode="updates",
+        subgraphs=True,
+        config=config,
+        durability="exit",
+    ):
+        chunk = list(chunk.values())[0]
+        if chunk is not None:
+            # Check for interrupts
+            if "__interrupt__" in chunk:
+                result = chunk
+                break
+            
+            # Normal message processing
+            if "messages" in chunk and chunk["messages"]:
+                last_message = chunk["messages"][-1]
+
+                message_content = None
+                message_role = getattr(last_message, "type", None)
+                if isinstance(message_role, dict):
+                    message_role = last_message.get("role", "unknown")
+
+                if hasattr(last_message, "content"):
+                    message_content = last_message.content
+                elif isinstance(last_message, dict) and "content" in last_message:
+                    message_content = last_message["content"]
+
+                if message_content:
+                    # Show tool calls with truncated args
+                    if message_role != "tool":
+                        if isinstance(message_content, list):
+                            for block in message_content:
+                                if isinstance(block, dict) and block.get("type") == "tool_use":
+                                    tool_name = block.get("name", "unknown_tool")
+                                    tool_input = block.get("input", {})
+                                    
+                                    tool_icons = {
+                                        "read_file": "📖",
+                                        "write_file": "✏️",
+                                        "edit_file": "✂️",
+                                        "ls": "📁",
+                                        "glob": "🔍",
+                                        "grep": "🔎",
+                                        "shell": "⚡",
+                                        "web_search": "🌐",
+                                        "http_request": "🌍",
+                                        "task": "🤖",
+                                        "write_todos": "📋",
+                                    }
+                                    
+                                    icon = tool_icons.get(tool_name, "🔧")
+                                    args_str = format_tool_args(tool_input)
+                                    
+                                    if args_str:
+                                        console.print(f"[dim]{icon} {tool_name}({args_str})[/dim]")
+                                    else:
+                                        console.print(f"[dim]{icon} {tool_name}()[/dim]")
+                    
+                    # Show tool results with truncation
+                    if message_role == "tool":
+                        result_str = str(message_content)
+                        result_str = truncate_value(result_str, MAX_RESULT_LENGTH)
+                        console.print(f"[dim]  → {result_str}[/dim]")
+                    
+                    # Show text content
+                    if message_role != "tool":
+                        has_text_content = False
+                        if isinstance(message_content, str):
+                            has_text_content = True
+                        elif isinstance(message_content, list):
+                            for block in message_content:
+                                if isinstance(block, dict):
+                                    if block.get("type") == "text" and block.get("text", "").strip():
+                                        has_text_content = True
+                                        break
+                        
+                        if has_text_content:
+                            extract_and_display_content(message_content)
+                            console.print()
+    
+    console.print()
+
+
+async def simple_cli(agent, agent_name: str | None):
+    """Main CLI loop."""
+    console.print()
+    console.print(Panel.fit(
+        "[bold cyan]DeepAgents[/bold cyan] [dim]|[/dim] AI Coding Assistant",
+        border_style="cyan",
+        box=box.DOUBLE
+    ))
+    console.print("[dim]Type 'quit' to exit[/dim]")
+    console.print()
+
+    while True:
+        try:
+            console.print("[bold green]❯[/bold green] ", end="")
+            user_input = input().strip()
+        except EOFError:
+            break
+
+        if not user_input:
+            continue
+
+        if user_input.lower() in ["quit", "exit", "q"]:
+            console.print("\n[bold cyan]👋 Goodbye![/bold cyan]\n")
+            break
+
+
+
+        else:
+            execute_task(user_input, agent, agent_name)
+
+
+def list_agents():
+    """List all available agents."""
+    agents_dir = Path.home() / ".deepagents"
+    
+    if not agents_dir.exists() or not any(agents_dir.iterdir()):
+        console.print("[yellow]No agents found.[/yellow]")
+        console.print("[dim]Agents will be created in ~/.deepagents/ when you first use them.[/dim]")
+        return
+    
+    console.print("\n[bold cyan]Available Agents:[/bold cyan]\n")
+    
+    for agent_path in sorted(agents_dir.iterdir()):
+        if agent_path.is_dir():
+            agent_name = agent_path.name
+            agent_md = agent_path / "agent.md"
+            
+            if agent_md.exists():
+                console.print(f"  [green]•[/green] [bold]{agent_name}[/bold]")
+                console.print(f"    [dim]{agent_path}[/dim]")
+            else:
+                console.print(f"  [yellow]•[/yellow] [bold]{agent_name}[/bold] [dim](incomplete)[/dim]")
+                console.print(f"    [dim]{agent_path}[/dim]")
+    
+    console.print()
+
+
+def reset_agent(agent_name: str, source_agent: str = None):
+    """Reset an agent to default or copy from another agent."""
+    agents_dir = Path.home() / ".deepagents"
+    agent_dir = agents_dir / agent_name
+    
+    if source_agent:
+        source_dir = agents_dir / source_agent
+        source_md = source_dir / "agent.md"
+        
+        if not source_md.exists():
+            console.print(f"[bold red]Error:[/bold red] Source agent '{source_agent}' not found or has no agent.md")
+            return
+        
+        source_content = source_md.read_text()
+        action_desc = f"contents of agent '{source_agent}'"
+    else:
+        source_content = get_default_coding_instructions()
+        action_desc = "default prompt"
+    
+    if agent_dir.exists():
+        shutil.rmtree(agent_dir)
+        console.print(f"[yellow]Removed existing agent directory:[/yellow] {agent_dir}")
+    
+    agent_dir.mkdir(parents=True, exist_ok=True)
+    agent_md = agent_dir / "agent.md"
+    agent_md.write_text(source_content)
+    
+    console.print(f"[bold green]✓[/bold green] Agent '{agent_name}' reset to {action_desc}")
+    console.print(f"[dim]Location: {agent_dir}[/dim]\n")
+
+
+def show_help():
+    """Show help information."""
+    help_text = """
+[bold cyan]DeepAgents - AI Coding Assistant[/bold cyan]
+
+[bold]Usage:[/bold]
+  deepagents [--agent NAME] [--no-memory]    Start interactive session
+  deepagents list                            List all available agents
+  deepagents reset --agent AGENT             Reset agent to default prompt
+  deepagents reset --agent AGENT --target SOURCE   Reset agent to copy of another agent
+  deepagents help                            Show this help message
+
+[bold]Examples:[/bold]
+  deepagents                          # Start with default agent (long-term memory enabled)
+  deepagents --agent mybot            # Start with agent named 'mybot'
+  deepagents --no-memory              # Start without long-term memory
+  deepagents list                     # List all agents
+  deepagents reset --agent mybot      # Reset mybot to default
+  deepagents reset --agent mybot --target other   # Reset mybot to copy of 'other' agent
+
+[bold]Long-term Memory:[/bold]
+  By default, long-term memory is ENABLED using agent name 'agent'.
+  Memory includes:
+  - Persistent agent.md file with your instructions
+  - /memories/ folder for storing context across sessions
+  
+  Use --no-memory to disable these features.
+  Note: --agent and --no-memory cannot be used together.
+
+[bold]Agent Storage:[/bold]
+  Agents are stored in: ~/.deepagents/AGENT_NAME/
+  Each agent has an agent.md file containing its prompt
+
+[bold]Interactive Commands:[/bold]
+  quit, exit, q    Exit the session
+  help             Show usage examples
+    """
+    console.print(help_text)
+
+
+def parse_args():
+    """Parse command line arguments."""
+    parser = argparse.ArgumentParser(
+        description="DeepAgents - AI Coding Assistant",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        add_help=False,
+    )
+    
+    subparsers = parser.add_subparsers(dest="command", help="Command to run")
+    
+    # List command
+    subparsers.add_parser("list", help="List all available agents")
+    
+    # Help command
+    subparsers.add_parser("help", help="Show help information")
+    
+    # Reset command
+    reset_parser = subparsers.add_parser("reset", help="Reset an agent")
+    reset_parser.add_argument("--agent", required=True, help="Name of agent to reset")
+    reset_parser.add_argument("--target", dest="source_agent", help="Copy prompt from another agent")
+    
+    # Default interactive mode
+    parser.add_argument(
+        "--agent",
+        default="agent",
+        help="Agent identifier for separate memory stores (default: agent).",
+    )
+    
+    parser.add_argument(
+        "--no-memory",
+        action="store_true",
+        help="Disable long-term memory features (no agent.md or /memories/ access).",
+    )
+    
+    return parser.parse_args()
+
+
+async def main(agent_name: str, no_memory: bool):
+    """Main entry point."""
+    # Error if both --agent and --no-memory are specified
+    if agent_name != "agent" and no_memory:
+        console.print("[bold red]Error:[/bold red] Cannot use --agent with --no-memory flag.")
+        console.print("Either specify --agent for memory-enabled mode, or use --no-memory for memory-disabled mode.")
+        return
+    
+    # Disable long-term memory if --no-memory flag is set
+    long_term_memory = not no_memory
+    
+    # If memory is disabled, set agent_name to None
+    effective_agent_name = None if no_memory else agent_name
+    
+    # Create agent with conditional tools
+    tools = [http_request]
+    if tavily_client is not None:
+        tools.append(web_search)
+    
+    agent = create_deep_agent(
+        tools=tools,
+        system_prompt=get_coding_instructions(effective_agent_name, long_term_memory=long_term_memory),
+        use_local_filesystem=True,
+        long_term_memory=long_term_memory,
+    ).with_config(config)
+    
+    agent.checkpointer = InMemorySaver()
+    
+    try:
+        await simple_cli(agent, effective_agent_name)
+    except KeyboardInterrupt:
+        console.print("\n\n[bold cyan]👋 Goodbye![/bold cyan]\n")
+    except Exception as e:
+        console.print(f"\n[bold red]❌ Error:[/bold red] {e}\n")
+
+
+def cli_main():
+    """Entry point for console script."""
+    args = parse_args()
+    
+    if args.command == "help":
+        show_help()
+    elif args.command == "list":
+        list_agents()
+    elif args.command == "reset":
+        reset_agent(args.agent, args.source_agent)
+    else:
+        asyncio.run(main(args.agent, args.no_memory))
+
+
+if __name__ == "__main__":
+    cli_main()

deepagents/default_agent_prompt.md

@@ -0,0 +1,91 @@
+You are an AI assistant that helps users with various tasks including coding, research, and analysis.
+
+# Core Role
+Your core role and behavior may be updated based on user feedback and instructions. When a user tells you how you should behave or what your role should be, update this memory file immediately to reflect that guidance.
+
+# Tone and Style
+Be concise and direct. Answer in fewer than 4 lines unless the user asks for detail.
+After working on a file, just stop - don't explain what you did unless asked.
+Avoid unnecessary introductions or conclusions.
+
+When you run non-trivial bash commands, briefly explain what they do.
+
+## Proactiveness
+Take action when asked, but don't surprise users with unrequested actions.
+If asked how to approach something, answer first before taking action.
+
+## Following Conventions
+- Check existing code for libraries and frameworks before assuming availability
+- Mimic existing code style, naming conventions, and patterns
+- Never add comments unless asked
+
+## Task Management
+Use write_todos for complex multi-step tasks (3+ steps). Mark tasks in_progress before starting, completed immediately after finishing.
+For simple 1-2 step tasks, just do them without todos.
+
+## Working with Subagents (task tool)
+When delegating to subagents:
+- **Use filesystem for large I/O**: If input instructions are large (>500 words) OR expected output is large, communicate via files
+  - Write input context/instructions to a file, tell subagent to read it
+  - Ask subagent to write their output to a file, then read it after they return
+  - This prevents token bloat and keeps context manageable in both directions
+- **Parallelize independent work**: When tasks are independent, spawn parallel subagents to work simultaneously
+- **Clear specifications**: Tell subagent exactly what format/structure you need in their response or output file
+- **Main agent synthesizes**: Subagents gather/execute, main agent integrates results into final deliverable
+
+## Tools
+
+### execute_bash
+Execute shell commands. Always quote paths with spaces.
+Examples: `pytest /foo/bar/tests` (good), `cd /foo/bar && pytest tests` (bad)
+
+### File Tools
+- read_file: Read file contents (use absolute paths)
+- edit_file: Replace exact strings in files (must read first, provide unique old_string)
+- write_file: Create or overwrite files
+- ls: List directory contents
+- glob: Find files by pattern (e.g., "**/*.py")
+- grep: Search file contents
+
+Always use absolute paths starting with /.
+
+### web_search
+Search for documentation, error solutions, and code examples.
+
+### http_request
+Make HTTP requests to APIs (GET, POST, etc.).
+
+## Code References
+When referencing code, use format: `file_path:line_number`
+
+## Documentation
+- Do NOT create excessive markdown summary/documentation files after completing work
+- Focus on the work itself, not documenting what you did
+- Only create documentation when explicitly requested
+
+## Long-term Memory
+You have access to a long-term memory system using the `/memories/` path prefix.
+Files stored in `/memories/` persist across sessions and are stored in your agent directory.
+
+Your system prompt is loaded from `/memories/agent.md` at startup. You can update your own instructions by editing this file.
+
+**When to update memories:**
+- **IMMEDIATELY when the user describes your role or how you should behave** (e.g., "you are a web researcher", "you are an expert in X")
+- **IMMEDIATELY when the user gives feedback on your work** - Before continuing, update memories to capture what was wrong and how to do it better
+- When the user explicitly asks you to remember something
+- When patterns or preferences emerge (coding styles, conventions, workflows)
+- After significant work where context would help in future sessions
+
+**Learning from feedback:**
+- When user says something is better/worse, capture WHY and encode it as a pattern
+- Each correction is a chance to improve permanently - don't just fix the immediate issue, update your instructions
+
+**What to store where:**
+- **`/memories/agent.md`**: Update this to modify your core instructions and behavioral patterns
+- **Other `/memories/` files**: Use for project-specific context, reference information, or structured notes
+  - If you create additional memory files, add references to them in `/memories/agent.md` so you remember to consult them
+
+The portion of your system prompt that comes from `/memories/agent.md` is marked with `<agent_memory>` tags so you can identify what instructions come from your persistent memory.
+
+Example: `edit_file('/memories/agent.md', ...)` to update your instructions
+Example: `write_file('/memories/project_context.md', ...)` for project-specific notes, then reference it in agent.md