deepagents-cli 0.0.4__tar.gz → 0.0.6__tar.gz

{deepagents_cli-0.0.4 → deepagents_cli-0.0.6}/PKG-INFO

@@ -1,11 +1,11 @@
 Metadata-Version: 2.4
 Name: deepagents-cli
-Version: 0.0.4
+Version: 0.0.6
 Summary: Deepagents CLI
 License: MIT
 Requires-Python: <4.0,>=3.11
 Description-Content-Type: text/markdown
-Requires-Dist: deepagents==0.2.2
+Requires-Dist: deepagents==0.2.3
 Requires-Dist: requests
 Requires-Dist: rich>=13.0.0
 Requires-Dist: prompt-toolkit>=3.0.52

{deepagents_cli-0.0.4 → deepagents_cli-0.0.6}/deepagents_cli/agent.py

@@ -79,35 +79,13 @@ def reset_agent(agent_name: str, source_agent: str = None):
     console.print(f"Location: {agent_dir}\n", style=COLORS["dim"])
 
 
-def create_agent_with_config(model, assistant_id: str, tools: list):
-    """Create and configure an agent with the specified model and tools."""
-    shell_middleware = ResumableShellToolMiddleware(
-        workspace_root=os.getcwd(), execution_policy=HostExecutionPolicy()
-    )
+def get_system_prompt() -> str:
+    """Get the base system prompt for the agent.
 
-    # For long-term memory, point to ~/.deepagents/AGENT_NAME/ with /memories/ prefix
-    agent_dir = Path.home() / ".deepagents" / assistant_id
-    agent_dir.mkdir(parents=True, exist_ok=True)
-    agent_md = agent_dir / "agent.md"
-    if not agent_md.exists():
-        source_content = get_default_coding_instructions()
-        agent_md.write_text(source_content)
-
-    # Long-term backend - rooted at agent directory
-    # This handles both /memories/ files and /agent.md
-    long_term_backend = FilesystemBackend(root_dir=agent_dir, virtual_mode=True)
-
-    # Composite backend: current working directory for default, agent directory for /memories/
-    backend = CompositeBackend(
-        default=FilesystemBackend(), routes={"/memories/": long_term_backend}
-    )
-
-    # Use the same backend for agent memory middleware
-    agent_middleware = [
-        AgentMemoryMiddleware(backend=long_term_backend, memory_path="/memories/"),
-        shell_middleware,
-    ]
-    system_prompt = f"""### Current Working Directory
+    Returns:
+        The system prompt string (without agent.md content)
+    """
+    return f"""### Current Working Directory
 
 The filesystem backend is currently operating in: `{Path.cwd()}`
 
@@ -159,6 +137,39 @@ When using the write_todos tool:
 
 The todo list is a planning tool - use it judiciously to avoid overwhelming the user with excessive task tracking."""
 
+
+def create_agent_with_config(model, assistant_id: str, tools: list):
+    """Create and configure an agent with the specified model and tools."""
+    shell_middleware = ResumableShellToolMiddleware(
+        workspace_root=os.getcwd(), execution_policy=HostExecutionPolicy()
+    )
+
+    # For long-term memory, point to ~/.deepagents/AGENT_NAME/ with /memories/ prefix
+    agent_dir = Path.home() / ".deepagents" / assistant_id
+    agent_dir.mkdir(parents=True, exist_ok=True)
+    agent_md = agent_dir / "agent.md"
+    if not agent_md.exists():
+        source_content = get_default_coding_instructions()
+        agent_md.write_text(source_content)
+
+    # Long-term backend - rooted at agent directory
+    # This handles both /memories/ files and /agent.md
+    long_term_backend = FilesystemBackend(root_dir=agent_dir, virtual_mode=True)
+
+    # Composite backend: current working directory for default, agent directory for /memories/
+    backend = CompositeBackend(
+        default=FilesystemBackend(), routes={"/memories/": long_term_backend}
+    )
+
+    # Use the same backend for agent memory middleware
+    agent_middleware = [
+        AgentMemoryMiddleware(backend=long_term_backend, memory_path="/memories/"),
+        shell_middleware,
+    ]
+
+    # Get the system prompt
+    system_prompt = get_system_prompt()
+
     # Helper functions for formatting tool descriptions in HITL prompts
     def format_write_file_description(tool_call: dict) -> str:
         """Format write_file tool call for approval prompt."""

{deepagents_cli-0.0.4 → deepagents_cli-0.0.6}/deepagents_cli/commands.py

@@ -20,6 +20,9 @@ def handle_command(command: str, agent, token_tracker: TokenTracker) -> str | bo
         # Reset agent conversation state
         agent.checkpointer = InMemorySaver()
 
+        # Reset token tracking to baseline
+        token_tracker.reset()
+
         # Clear screen and show fresh UI
         console.clear()
         console.print(DEEP_AGENTS_ASCII, style=f"bold {COLORS['primary']}")

deepagents_cli-0.0.6/deepagents_cli/default_agent_prompt.md

@@ -0,0 +1,110 @@
+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.
+
+## Memory-First Protocol
+You have access to a persistent memory system. ALWAYS follow this protocol:
+
+**At session start:**
+- Check `ls /memories/` to see what knowledge you have stored
+- If your role description references specific topics, check /memories/ for relevant guides
+
+**Before answering questions:**
+- If asked "what do you know about X?" or "how do I do Y?" → Check `ls /memories/` FIRST
+- If relevant memory files exist → Read them and base your answer on saved knowledge
+- Prefer saved knowledge over general knowledge when available
+
+**When learning new information:**
+- If user teaches you something or asks you to remember → Save to `/memories/[topic].md`
+- Use descriptive filenames: `/memories/deep-agents-guide.md` not `/memories/notes.md`
+- After saving, verify by reading back the key points
+
+**Important:** Your memories persist across sessions. Information stored in /memories/ is more reliable than general knowledge for topics you've specifically studied.
+
+# 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.
+
+## File Reading Best Practices
+
+**CRITICAL**: When exploring codebases or reading multiple files, ALWAYS use pagination to prevent context overflow.
+
+**Pattern for codebase exploration:**
+1. First scan: `read_file(path, limit=100)` - See file structure and key sections
+2. Targeted read: `read_file(path, offset=100, limit=200)` - Read specific sections if needed
+3. Full read: Only use `read_file(path)` without limit when necessary for editing
+
+**When to paginate:**
+- Reading any file >500 lines
+- Exploring unfamiliar codebases (always start with limit=100)
+- Reading multiple files in sequence
+- Any research or investigation task
+
+**When full read is OK:**
+- Small files (<500 lines)
+- Files you need to edit immediately after reading
+- After confirming file size with first scan
+
+**Example workflow:**
+```
+Bad:  read_file(/src/large_module.py)  # Floods context with 2000+ lines
+Good: read_file(/src/large_module.py, limit=100)  # Scan structure first
+      read_file(/src/large_module.py, offset=100, limit=100)  # Read relevant section
+```
+
+## 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

{deepagents_cli-0.0.4 → deepagents_cli-0.0.6}/deepagents_cli/main.py

@@ -93,7 +93,7 @@ def parse_args():
     return parser.parse_args()
 
 
-async def simple_cli(agent, assistant_id: str | None, session_state):
+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']}")
@@ -131,6 +131,7 @@ async def simple_cli(agent, assistant_id: str | None, session_state):
     # 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:
@@ -181,8 +182,16 @@ async def main(assistant_id: str, session_state):
 
     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)
+        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")
 

deepagents_cli-0.0.6/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-0.0.4 → deepagents_cli-0.0.6}/deepagents_cli/ui.py

@@ -165,7 +165,22 @@ class TokenTracker:
     """Track token usage across the conversation."""
 
     def __init__(self):
-        self.current_context = 0
+        self.baseline_context = 0  # Baseline system context (system + agent.md + tools)
+        self.current_context = 0   # Total context including messages
+        self.last_output = 0
+
+    def set_baseline(self, tokens: int):
+        """Set the baseline context token count.
+
+        Args:
+            tokens: The baseline token count (system prompt + agent.md + tools)
+        """
+        self.baseline_context = tokens
+        self.current_context = tokens
+
+    def reset(self):
+        """Reset to baseline (for /clear command)."""
+        self.current_context = self.baseline_context
         self.last_output = 0
 
     def add(self, input_tokens: int, output_tokens: int):
@@ -183,12 +198,31 @@ class TokenTracker:
 
     def display_session(self):
         """Display current context size."""
-        if self.current_context:
-            console.print("\n[bold]Token Usage:[/bold]", style=COLORS["primary"])
+        console.print("\n[bold]Token Usage:[/bold]", style=COLORS["primary"])
+
+        # Check if we've had any actual API calls yet (current > baseline means we have conversation)
+        has_conversation = self.current_context > self.baseline_context
+
+        if self.baseline_context > 0:
+            console.print(
+                f"  Baseline: {self.baseline_context:,} tokens [dim](system + agent.md)[/dim]",
+                style=COLORS["dim"],
+            )
+
+            if not has_conversation:
+                # Before first message - warn that tools aren't counted yet
+                console.print(
+                    "  [dim]Note: Tool definitions (~5k tokens) included after first message[/dim]"
+                )
+
+        if has_conversation:
+            tools_and_conversation = self.current_context - self.baseline_context
             console.print(
-                f"  Current context: {self.current_context:,} tokens", style=COLORS["dim"]
+                f"  Tools + conversation: {tools_and_conversation:,} tokens", style=COLORS["dim"]
             )
-            console.print()
+
+        console.print(f"  Total: {self.current_context:,} tokens", style="bold " + COLORS["dim"])
+        console.print()
 
 
 def render_todo_list(todos: list[dict]) -> None:

{deepagents_cli-0.0.4 → deepagents_cli-0.0.6}/deepagents_cli.egg-info/PKG-INFO

@@ -1,11 +1,11 @@
 Metadata-Version: 2.4
 Name: deepagents-cli
-Version: 0.0.4
+Version: 0.0.6
 Summary: Deepagents CLI
 License: MIT
 Requires-Python: <4.0,>=3.11
 Description-Content-Type: text/markdown
-Requires-Dist: deepagents==0.2.2
+Requires-Dist: deepagents==0.2.3
 Requires-Dist: requests
 Requires-Dist: rich>=13.0.0
 Requires-Dist: prompt-toolkit>=3.0.52

{deepagents_cli-0.0.4 → deepagents_cli-0.0.6}/deepagents_cli.egg-info/SOURCES.txt

@@ -6,11 +6,13 @@ deepagents_cli/agent.py
 deepagents_cli/cli.py
 deepagents_cli/commands.py
 deepagents_cli/config.py
+deepagents_cli/default_agent_prompt.md
 deepagents_cli/execution.py
 deepagents_cli/file_ops.py
 deepagents_cli/input.py
 deepagents_cli/main.py
 deepagents_cli/py.typed
+deepagents_cli/token_utils.py
 deepagents_cli/tools.py
 deepagents_cli/ui.py
 deepagents_cli.egg-info/PKG-INFO

{deepagents_cli-0.0.4 → deepagents_cli-0.0.6}/deepagents_cli.egg-info/requires.txt

@@ -1,4 +1,4 @@
-deepagents==0.2.2
+deepagents==0.2.3
 requests
 rich>=13.0.0
 prompt-toolkit>=3.0.52

{deepagents_cli-0.0.4 → deepagents_cli-0.0.6}/pyproject.toml

@@ -1,12 +1,12 @@
 [project]
 name = "deepagents-cli"
-version = "0.0.4"
+version = "0.0.6"
 description = "Deepagents CLI"
 readme = "README.md"
 license = { text = "MIT" }
 requires-python = ">=3.11,<4.0"
 dependencies = [
-  "deepagents==0.2.2",
+  "deepagents==0.2.3",
   "requests",
   "rich>=13.0.0",
   "prompt-toolkit>=3.0.52",
@@ -54,6 +54,9 @@ lint = [
 requires = ["setuptools>=73.0.0", "wheel"]
 build-backend = "setuptools.build_meta"
 
+[tool.setuptools.package-data]
+deepagents_cli = ["default_agent_prompt.md"]
+
 [tool.ruff]
 line-length = 100
 exclude = []