deepagents-cli 0.0.3__py3-none-any.whl → 0.0.5__py3-none-any.whl

deepagents_cli/main.py

@@ -0,0 +1,226 @@
+"""Main entry point and CLI loop for deepagents."""
+
+import argparse
+import asyncio
+import sys
+from pathlib import Path
+
+from .agent import create_agent_with_config, list_agents, reset_agent
+from .commands import execute_bash_command, handle_command
+from .config import COLORS, DEEP_AGENTS_ASCII, SessionState, console, create_model
+from .execution import execute_task
+from .input import create_prompt_session
+from .tools import http_request, tavily_client, web_search
+from .ui import TokenTracker, show_help
+
+
+def check_cli_dependencies():
+    """Check if CLI optional dependencies are installed."""
+    missing = []
+
+    try:
+        import rich
+    except ImportError:
+        missing.append("rich")
+
+    try:
+        import requests
+    except ImportError:
+        missing.append("requests")
+
+    try:
+        import dotenv
+    except ImportError:
+        missing.append("python-dotenv")
+
+    try:
+        import tavily
+    except ImportError:
+        missing.append("tavily-python")
+
+    try:
+        import prompt_toolkit
+    except ImportError:
+        missing.append("prompt-toolkit")
+
+    if missing:
+        print("\n❌ Missing required CLI dependencies!")
+        print("\nThe following packages are required to use the deepagents CLI:")
+        for pkg in missing:
+            print(f"  - {pkg}")
+        print("\nPlease install them with:")
+        print("  pip install deepagents[cli]")
+        print("\nOr install all dependencies:")
+        print("  pip install 'deepagents[cli]'")
+        sys.exit(1)
+
+
+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(
+        "--auto-approve",
+        action="store_true",
+        help="Auto-approve tool usage without prompting (disables human-in-the-loop)",
+    )
+
+    return parser.parse_args()
+
+
+async def simple_cli(agent, assistant_id: str | None, session_state, baseline_tokens: int = 0):
+    """Main CLI loop."""
+    console.clear()
+    console.print(DEEP_AGENTS_ASCII, style=f"bold {COLORS['primary']}")
+    console.print()
+
+    if tavily_client is None:
+        console.print(
+            "[yellow]⚠ Web search disabled:[/yellow] TAVILY_API_KEY not found.",
+            style=COLORS["dim"],
+        )
+        console.print("  To enable web search, set your Tavily API key:", style=COLORS["dim"])
+        console.print("    export TAVILY_API_KEY=your_api_key_here", style=COLORS["dim"])
+        console.print(
+            "  Or add it to your .env file. Get your key at: https://tavily.com",
+            style=COLORS["dim"],
+        )
+        console.print()
+
+    console.print("... Ready to code! What would you like to build?", style=COLORS["agent"])
+    console.print(f"  [dim]Working directory: {Path.cwd()}[/dim]")
+    console.print()
+
+    if session_state.auto_approve:
+        console.print(
+            "  [yellow]⚡ Auto-approve: ON[/yellow] [dim](tools run without confirmation)[/dim]"
+        )
+        console.print()
+
+    console.print(
+        "  Tips: Enter to submit, Alt+Enter for newline, Ctrl+E for editor, Ctrl+T to toggle auto-approve, Ctrl+C to interrupt",
+        style=f"dim {COLORS['dim']}",
+    )
+    console.print()
+
+    # Create prompt session and token tracker
+    session = create_prompt_session(assistant_id, session_state)
+    token_tracker = TokenTracker()
+    token_tracker.set_baseline(baseline_tokens)
+
+    while True:
+        try:
+            user_input = await session.prompt_async()
+            user_input = user_input.strip()
+        except EOFError:
+            break
+        except KeyboardInterrupt:
+            # Ctrl+C at prompt - exit the program
+            console.print("\n\nGoodbye!", style=COLORS["primary"])
+            break
+
+        if not user_input:
+            continue
+
+        # Check for slash commands first
+        if user_input.startswith("/"):
+            result = handle_command(user_input, agent, token_tracker)
+            if result == "exit":
+                console.print("\nGoodbye!", style=COLORS["primary"])
+                break
+            if result:
+                # Command was handled, continue to next input
+                continue
+
+        # Check for bash commands (!)
+        if user_input.startswith("!"):
+            execute_bash_command(user_input)
+            continue
+
+        # Handle regular quit keywords
+        if user_input.lower() in ["quit", "exit", "q"]:
+            console.print("\nGoodbye!", style=COLORS["primary"])
+            break
+
+        execute_task(user_input, agent, assistant_id, session_state, token_tracker)
+
+
+async def main(assistant_id: str, session_state):
+    """Main entry point."""
+    # Create the model (checks API keys)
+    model = create_model()
+
+    # Create agent with conditional tools
+    tools = [http_request]
+    if tavily_client is not None:
+        tools.append(web_search)
+
+    agent = create_agent_with_config(model, assistant_id, tools)
+
+    # Calculate baseline token count for accurate token tracking
+    from .agent import get_system_prompt
+    from .token_utils import calculate_baseline_tokens
+
+    agent_dir = Path.home() / ".deepagents" / assistant_id
+    system_prompt = get_system_prompt()
+    baseline_tokens = calculate_baseline_tokens(model, agent_dir, system_prompt)
+
+    try:
+        await simple_cli(agent, assistant_id, session_state, baseline_tokens)
+    except Exception as e:
+        console.print(f"\n[bold red]❌ Error:[/bold red] {e}\n")
+
+
+def cli_main():
+    """Entry point for console script."""
+    # Check dependencies first
+    check_cli_dependencies()
+
+    try:
+        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:
+            # Create session state from args
+            session_state = SessionState(auto_approve=args.auto_approve)
+
+            # API key validation happens in create_model()
+            asyncio.run(main(args.agent, session_state))
+    except KeyboardInterrupt:
+        # Clean exit on Ctrl+C - suppress ugly traceback
+        console.print("\n\n[yellow]Interrupted[/yellow]")
+        sys.exit(0)
+
+
+if __name__ == "__main__":
+    cli_main()

deepagents_cli/token_utils.py

@@ -0,0 +1,63 @@
+"""Utilities for accurate token counting using LangChain models."""
+
+from pathlib import Path
+
+from langchain_core.messages import SystemMessage
+
+from .config import console
+
+
+def calculate_baseline_tokens(model, agent_dir: Path, system_prompt: str) -> int:
+    """Calculate baseline context tokens using the model's official tokenizer.
+
+    This uses the model's get_num_tokens_from_messages() method to get
+    accurate token counts for the initial context (system prompt + agent.md).
+
+    Note: Tool definitions cannot be accurately counted before the first API call
+    due to LangChain limitations. They will be included in the total after the
+    first message is sent (~5,000 tokens).
+
+    Args:
+        model: LangChain model instance (ChatAnthropic or ChatOpenAI)
+        agent_dir: Path to agent directory containing agent.md
+        system_prompt: The base system prompt string
+
+    Returns:
+        Token count for system prompt + agent.md (tools not included)
+    """
+    # Load agent.md content
+    agent_md_path = agent_dir / "agent.md"
+    agent_memory = ""
+    if agent_md_path.exists():
+        agent_memory = agent_md_path.read_text()
+
+    # Build the complete system prompt as it will be sent
+    # This mimics what AgentMemoryMiddleware.wrap_model_call() does
+    memory_section = f"<agent_memory>\n{agent_memory}\n</agent_memory>"
+
+    # Get the long-term memory system prompt
+    memory_system_prompt = get_memory_system_prompt()
+
+    # Combine all parts in the same order as the middleware
+    full_system_prompt = memory_section + "\n\n" + system_prompt + "\n\n" + memory_system_prompt
+
+    # Count tokens using the model's official method
+    messages = [SystemMessage(content=full_system_prompt)]
+
+    try:
+        # Note: tools parameter is not supported by LangChain's token counting
+        # Tool tokens will be included in the API response after first message
+        token_count = model.get_num_tokens_from_messages(messages)
+        return token_count
+    except Exception as e:
+        # Fallback if token counting fails
+        console.print(f"[yellow]Warning: Could not calculate baseline tokens: {e}[/yellow]")
+        return 0
+
+
+def get_memory_system_prompt() -> str:
+    """Get the long-term memory system prompt text."""
+    # Import from agent_memory middleware
+    from deepagents.middleware.agent_memory import LONGTERM_MEMORY_SYSTEM_PROMPT
+
+    return LONGTERM_MEMORY_SYSTEM_PROMPT.format(memory_path="/memories/")

deepagents_cli/tools.py

@@ -0,0 +1,140 @@
+"""Custom tools for the CLI agent."""
+
+import os
+from typing import Any, Literal
+
+import requests
+from tavily import TavilyClient
+
+# Initialize Tavily client if API key is available
+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: 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: {e!s}",
+            "url": url,
+        }
+    except Exception as e:
+        return {
+            "success": False,
+            "status_code": 0,
+            "headers": {},
+            "content": f"Error making request: {e!s}",
+            "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 current information and documentation.
+
+    This tool searches the web and returns relevant results. After receiving results,
+    you MUST synthesize the information into a natural, helpful response for the user.
+
+    Args:
+        query: The search query (be specific and detailed)
+        max_results: Number of results to return (default: 5)
+        topic: Search topic type - "general" for most queries, "news" for current events
+        include_raw_content: Include full page content (warning: uses more tokens)
+
+    Returns:
+        Dictionary containing:
+        - results: List of search results, each with:
+            - title: Page title
+            - url: Page URL
+            - content: Relevant excerpt from the page
+            - score: Relevance score (0-1)
+        - query: The original search query
+
+    IMPORTANT: After using this tool:
+    1. Read through the 'content' field of each result
+    2. Extract relevant information that answers the user's question
+    3. Synthesize this into a clear, natural language response
+    4. Cite sources by mentioning the page titles or URLs
+    5. NEVER show the raw JSON to the user - always provide a formatted response
+    """
+    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: {e!s}", "query": query}