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

deepagents_cli/agent.py

@@ -7,11 +7,11 @@ from pathlib import Path
 from deepagents import create_deep_agent
 from deepagents.backends import CompositeBackend
 from deepagents.backends.filesystem import FilesystemBackend
-from deepagents.middleware.agent_memory import AgentMemoryMiddleware
 from deepagents.middleware.resumable_shell import ResumableShellToolMiddleware
 from langchain.agents.middleware import HostExecutionPolicy
 from langgraph.checkpoint.memory import InMemorySaver
 
+from .agent_memory import AgentMemoryMiddleware
 from .config import COLORS, config, console, get_default_coding_instructions
 
 

deepagents_cli/agent_memory.py

@@ -0,0 +1,222 @@
+"""Middleware for loading agent-specific long-term memory into the system prompt."""
+
+from collections.abc import Awaitable, Callable
+from typing import TYPE_CHECKING, Any
+
+if TYPE_CHECKING:
+    from langgraph.runtime import Runtime
+
+from langchain.agents.middleware.types import (
+    AgentMiddleware,
+    AgentState,
+    ModelRequest,
+    ModelResponse,
+)
+from typing_extensions import NotRequired, TypedDict
+
+from deepagents.backends.protocol import BackendProtocol
+
+
+class AgentMemoryState(AgentState):
+    """State for the agent memory middleware."""
+
+    agent_memory: NotRequired[str | None]
+    """Long-term memory content for the agent."""
+
+
+AGENT_MEMORY_FILE_PATH = "/agent.md"
+
+# Long-term Memory Documentation
+LONGTERM_MEMORY_SYSTEM_PROMPT = """
+
+## Long-term Memory
+
+You have access to a long-term memory system using the {memory_path} path prefix.
+Files stored in {memory_path} persist across sessions and conversations.
+
+Your system prompt is loaded from {memory_path}agent.md at startup. You can update your own instructions by editing this file.
+
+**When to CHECK/READ memories (CRITICAL - do this FIRST):**
+- **At the start of ANY new session**: Run `ls {memory_path}` to see what you know
+- **BEFORE answering questions**: If asked "what do you know about X?" or "how do I do Y?", check `ls {memory_path}` for relevant files FIRST
+- **When user asks you to do something**: Check if you have guides, examples, or patterns in {memory_path} before proceeding
+- **When user references past work or conversations**: Search {memory_path} for related content
+- **If you're unsure**: Check your memories rather than guessing or using only general knowledge
+
+**Memory-first response pattern:**
+1. User asks a question → Run `ls {memory_path}` to check for relevant files
+2. If relevant files exist → Read them with `read_file {memory_path}[filename]`
+3. Base your answer on saved knowledge (from memories) supplemented by general knowledge
+4. If no relevant memories exist → Use general knowledge, then consider if this is worth saving
+
+**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
+- When user says "you should remember X" or "be careful about Y", treat this as HIGH PRIORITY - update memories IMMEDIATELY
+- Look for the underlying principle behind corrections, not just the specific mistake
+- If it's something you "should have remembered", identify where that instruction should live permanently
+
+**What to store where:**
+- **{memory_path}agent.md**: Update this to modify your core instructions and behavioral patterns
+- **Other {memory_path} files**: Use for project-specific context, reference information, or structured notes
+  - If you create additional memory files, add references to them in {memory_path}agent.md so you remember to consult them
+
+The portion of your system prompt that comes from {memory_path}agent.md is marked with `<agent_memory>` tags so you can identify what instructions come from your persistent memory.
+
+Example: `ls {memory_path}` to see what memories you have
+Example: `read_file '{memory_path}deep-agents-guide.md'` to recall saved knowledge
+Example: `edit_file('{memory_path}agent.md', ...)` to update your instructions
+Example: `write_file('{memory_path}project_context.md', ...)` for project-specific notes, then reference it in agent.md
+
+Remember: To interact with the longterm filesystem, you must prefix the filename with the {memory_path} path."""
+
+
+DEFAULT_MEMORY_SNIPPET = """<agent_memory>
+{agent_memory}
+</agent_memory>
+"""
+
+class AgentMemoryMiddleware(AgentMiddleware):
+    """Middleware for loading agent-specific long-term memory.
+
+    This middleware loads the agent's long-term memory from a file (agent.md)
+    and injects it into the system prompt. The memory is loaded once at the
+    start of the conversation and stored in state.
+
+    Args:
+        backend: Backend to use for loading the agent memory file.
+        system_prompt_template: Optional custom template for how to inject
+            the agent memory into the system prompt. Use {agent_memory} as
+            a placeholder. Defaults to a simple section header.
+
+    Example:
+        ```python
+        from deepagents.middleware.agent_memory import AgentMemoryMiddleware
+        from deepagents.memory.backends import FilesystemBackend
+        from pathlib import Path
+
+        # Set up backend pointing to agent's directory
+        agent_dir = Path.home() / ".deepagents" / "my-agent"
+        backend = FilesystemBackend(root_dir=agent_dir)
+        
+        # Create middleware
+        middleware = AgentMemoryMiddleware(backend=backend)
+        ```
+    """
+
+    state_schema = AgentMemoryState
+
+    def __init__(
+        self,
+        *,
+        backend: BackendProtocol,
+        memory_path: str,
+        system_prompt_template: str | None = None,
+    ) -> None:
+        """Initialize the agent memory middleware.
+
+        Args:
+            backend: Backend to use for loading the agent memory file.
+            system_prompt_template: Optional custom template for injecting
+                agent memory into system prompt.
+        """
+        self.backend = backend
+        self.memory_path = memory_path
+        self.system_prompt_template = system_prompt_template or DEFAULT_MEMORY_SNIPPET
+
+    def before_agent(
+        self,
+        state: AgentMemoryState,
+        runtime,
+    ) -> AgentMemoryState:
+        """Load agent memory from file before agent execution.
+
+        Args:
+            state: Current agent state.
+            handler: Handler function to call after loading memory.
+
+        Returns:
+            Updated state with agent_memory populated.
+        """
+        # Only load memory if it hasn't been loaded yet
+        if "agent_memory" not in state or state.get("agent_memory") is None:
+            file_data = self.backend.read(AGENT_MEMORY_FILE_PATH)
+            return {"agent_memory": file_data}
+
+    async def abefore_agent(
+        self,
+        state: AgentMemoryState,
+        runtime,
+    ) -> AgentMemoryState:
+        """(async) Load agent memory from file before agent execution.
+
+        Args:
+            state: Current agent state.
+            handler: Handler function to call after loading memory.
+
+        Returns:
+            Updated state with agent_memory populated.
+        """
+        # Only load memory if it hasn't been loaded yet
+        if "agent_memory" not in state or state.get("agent_memory") is None:
+            file_data = self.backend.read(AGENT_MEMORY_FILE_PATH)
+            return {"agent_memory": file_data}
+
+    def wrap_model_call(
+        self,
+        request: ModelRequest,
+        handler: Callable[[ModelRequest], ModelResponse],
+    ) -> ModelResponse:
+        """Inject agent memory into the system prompt.
+
+        Args:
+            request: The model request being processed.
+            handler: The handler function to call with the modified request.
+
+        Returns:
+            The model response from the handler.
+        """
+        # Get agent memory from state
+        agent_memory = request.state.get("agent_memory", "")
+        
+        memory_section = self.system_prompt_template.format(agent_memory=agent_memory)
+        if request.system_prompt:
+            request.system_prompt = memory_section + "\n\n" + request.system_prompt
+        else:
+            request.system_prompt = memory_section
+        request.system_prompt = request.system_prompt + "\n\n" + LONGTERM_MEMORY_SYSTEM_PROMPT.format(memory_path=self.memory_path)
+
+        return handler(request)
+
+    async def awrap_model_call(
+        self,
+        request: ModelRequest,
+        handler: Callable[[ModelRequest], Awaitable[ModelResponse]],
+    ) -> ModelResponse:
+        """(async) Inject agent memory into the system prompt.
+
+        Args:
+            request: The model request being processed.
+            handler: The handler function to call with the modified request.
+
+        Returns:
+            The model response from the handler.
+        """
+        # Get agent memory from state
+        agent_memory = request.state.get("agent_memory", "")
+        
+        memory_section = self.system_prompt_template.format(agent_memory=agent_memory)
+        if request.system_prompt:
+            request.system_prompt = memory_section + "\n\n" + request.system_prompt
+        else:
+            request.system_prompt = memory_section
+        request.system_prompt = request.system_prompt + "\n\n" + LONGTERM_MEMORY_SYSTEM_PROMPT.format(memory_path=self.memory_path)
+
+        return await handler(request)

deepagents_cli/config.py

@@ -94,7 +94,7 @@ def get_default_coding_instructions() -> str:
     These are the immutable base instructions that cannot be modified by the agent.
     Long-term memory (agent.md) is handled separately by the middleware.
     """
-    default_prompt_path = Path(__file__).parent.parent / "default_agent_prompt.md"
+    default_prompt_path = Path(__file__).parent / "default_agent_prompt.md"
     return default_prompt_path.read_text()
 
 

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/token_utils.py

@@ -58,6 +58,6 @@ def calculate_baseline_tokens(model, agent_dir: Path, system_prompt: str) -> int
 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
+    from .agent_memory import LONGTERM_MEMORY_SYSTEM_PROMPT
 
     return LONGTERM_MEMORY_SYSTEM_PROMPT.format(memory_path="/memories/")

{deepagents_cli-0.0.5.dist-info → deepagents_cli-0.0.7.dist-info}/METADATA

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

{deepagents_cli-0.0.5.dist-info → deepagents_cli-0.0.7.dist-info}/RECORD

@@ -1,19 +1,21 @@
 deepagents_cli/__init__.py,sha256=2W9tHzQianR_Q0ku9hc_ZI3kUYsilXQ6I_kUnpg9bzg,108
 deepagents_cli/__main__.py,sha256=J9-RNZv_zxw4SyjWRI_N7k7m8G4--vclD8vKxYIiXPQ,128
-deepagents_cli/agent.py,sha256=4XCBPb_f-WN4uYCXUYvLath_9-uNYq0_mC2xXFiA4Ho,11087
+deepagents_cli/agent.py,sha256=8GFi9XtfedYTL0J-f72ARb_glklIIFCyzI_9buAg3h4,11066
+deepagents_cli/agent_memory.py,sha256=BRP8Dyuzl1ms4Eja-3nRHI3g2vNWfK8tUW6zBr2JJOc,9196
 deepagents_cli/cli.py,sha256=UE8l9crBCykfYSVb_NN9bhIhc0ECxsKnOjMC6DeoNdM,274
 deepagents_cli/commands.py,sha256=rHsHij1xGs13N_m46YcBP2M2_MRGqRbSlnWaZaMnoco,2606
-deepagents_cli/config.py,sha256=xVVc0JAERIgPKUr77sJ7ZTkT9LRgvZg7i4H6Fy_h8ts,5023
+deepagents_cli/config.py,sha256=lSwgL0uSq28GEODnZ2V_tstwY_QahIo1LcqA5RZ6zk4,5016
+deepagents_cli/default_agent_prompt.md,sha256=Pi9SvgOAa74qhgDUMexm2-S_OfUO_CTic3zdbUnuB4s,4964
 deepagents_cli/execution.py,sha256=nW_jFWoLJtvDfqeaPCGQJd3c8QwnsNV8SU4Y60eqtKE,27137
 deepagents_cli/file_ops.py,sha256=LQ7NTXPWLwePbiTBDA-22_VHxEGil7NpBltHZx1C7r4,12362
 deepagents_cli/input.py,sha256=B0bEJ_n5oPh6ra09lxOwYpebjko-z-_R4QOpSTX4fUs,9187
 deepagents_cli/main.py,sha256=iaN6FNwUwTwoTMrHOKqRrXtjTjuM0YXthAfPlcz-GeU,7144
 deepagents_cli/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-deepagents_cli/token_utils.py,sha256=45l3DjXgZAGAWgxXCnAx2nkY9t940B4M_rpAQmkLxUw,2460
+deepagents_cli/token_utils.py,sha256=tEeghLW2-vsitc-ba9cklKYnjLgRpvK7rK7PRiUu8jA,2439
 deepagents_cli/tools.py,sha256=Av92Luq-vGgUr25DqErGi7aI6y6DdFSXLigffhNLxYk,4287
 deepagents_cli/ui.py,sha256=Sjs40onvNpZP7OLxitlspL0o4SJj96aFboVxw4R_Aos,18668
-deepagents_cli-0.0.5.dist-info/METADATA,sha256=UW0GdBPkumAwstBmzYujqppRN06EO51dQkNrwH1tT64,434
-deepagents_cli-0.0.5.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-deepagents_cli-0.0.5.dist-info/entry_points.txt,sha256=oXSXGkStJ_8zP1gRFiHMU_GozXzWrE_CMIE228_yDHQ,96
-deepagents_cli-0.0.5.dist-info/top_level.txt,sha256=jEtsyDRyzAREUkw_cNOYGJqp72yvMICTBUaMV110w80,15
-deepagents_cli-0.0.5.dist-info/RECORD,,
+deepagents_cli-0.0.7.dist-info/METADATA,sha256=iG5whX5HTqTowo1Pwk1I75OvPwqGRuPFCGXBIKsFGhM,434
+deepagents_cli-0.0.7.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+deepagents_cli-0.0.7.dist-info/entry_points.txt,sha256=oXSXGkStJ_8zP1gRFiHMU_GozXzWrE_CMIE228_yDHQ,96
+deepagents_cli-0.0.7.dist-info/top_level.txt,sha256=jEtsyDRyzAREUkw_cNOYGJqp72yvMICTBUaMV110w80,15
+deepagents_cli-0.0.7.dist-info/RECORD,,