aloop 0.1.0__py3-none-any.whl

tools/notify.py

@@ -0,0 +1,69 @@
+"""Email notification tool using Resend API."""
+
+from typing import Any, Dict
+
+import httpx
+
+from config import Config
+from tools.base import BaseTool
+
+RESEND_API_URL = "https://api.resend.com/emails"
+
+
+class NotifyTool(BaseTool):
+    """Send email notifications via Resend."""
+
+    @property
+    def name(self) -> str:
+        return "notify"
+
+    @property
+    def description(self) -> str:
+        return "Send an email notification via Resend."
+
+    @property
+    def parameters(self) -> Dict[str, Any]:
+        return {
+            "recipient": {
+                "type": "string",
+                "description": "Recipient email address.",
+            },
+            "subject": {
+                "type": "string",
+                "description": "Email subject line.",
+            },
+            "body": {
+                "type": "string",
+                "description": "Email body (plain text).",
+            },
+        }
+
+    async def execute(self, recipient: str, subject: str, body: str) -> str:
+        if not recipient:
+            return "Error: recipient email address is required."
+
+        api_key = Config.RESEND_API_KEY
+        if not api_key:
+            return "Error: RESEND_API_KEY is not configured in .aloop/config."
+
+        from_addr = Config.NOTIFY_EMAIL_FROM
+        if not from_addr:
+            return "Error: NOTIFY_EMAIL_FROM is not configured in .aloop/config."
+
+        try:
+            async with httpx.AsyncClient() as client:
+                resp = await client.post(
+                    RESEND_API_URL,
+                    headers={"Authorization": f"Bearer {api_key}"},
+                    json={
+                        "from": from_addr,
+                        "to": [recipient],
+                        "subject": subject,
+                        "text": body,
+                    },
+                )
+            if resp.status_code == 200:
+                return f"Email sent successfully to {recipient}."
+            return f"Error sending email: {resp.status_code} {resp.text}"
+        except Exception as e:
+            return f"Error sending email: {e}"

tools/parallel_execute.py

@@ -0,0 +1,420 @@
+"""Parallel execution tool for dependency-aware task execution."""
+
+import asyncio
+from typing import TYPE_CHECKING, Any, Dict, List, Set
+
+from llm import LLMMessage
+
+from .base import BaseTool
+
+if TYPE_CHECKING:
+    from agent.base import BaseAgent
+
+
+# Allowed tools for subtask execution
+# Note: explore_context is allowed (one level of nesting), but parallel_execute is NOT
+ALLOWED_SUBTASK_TOOLS = {
+    "glob_files",
+    "grep_content",
+    "read_file",
+    "write_file",
+    "edit_file",
+    "smart_edit",
+    "search_files",
+    "code_navigator",
+    "shell",
+    "calculate",
+    "web_search",
+    "web_fetch",
+    "explore_context",  # Allow one level of nesting
+    # "parallel_execute" - NOT included to prevent recursion
+}
+
+
+class ParallelExecutionTool(BaseTool):
+    """Tool for executing tasks with dependencies in parallel.
+
+    This tool enables the main agent to execute multiple tasks concurrently
+    while respecting dependency relationships between them.
+
+    Key features:
+    - Dependency-aware execution ordering
+    - Parallel execution of independent tasks
+    - Cycle detection to prevent deadlocks
+    - One level of nesting (subtasks can use explore_context but not parallel_execute)
+    """
+
+    # Configuration
+    MAX_PARALLEL_TASKS = 4
+    MAX_RESULT_CHARS = 2000
+
+    def __init__(self, agent: "BaseAgent"):
+        """Initialize parallel execution tool.
+
+        Args:
+            agent: The parent agent instance that will execute tasks
+        """
+        self.agent = agent
+
+    @property
+    def name(self) -> str:
+        return "parallel_execute"
+
+    @property
+    def description(self) -> str:
+        return """Execute multiple tasks with dependencies in parallel.
+
+Use this tool when you need to:
+- Execute 3+ independent or semi-dependent tasks concurrently
+- Perform operations that can be parallelized for efficiency
+- Execute a structured plan with dependency relationships
+
+DO NOT use this for:
+- Simple sequential tasks (execute them directly)
+- Tasks with complex interdependencies (use regular sequential execution)
+- Single tasks (use regular tools directly)
+
+Input parameters:
+- tasks (required): Array of task descriptions (strings)
+- dependencies (optional): Object mapping task index to array of dependency indices
+  Example: {"2": ["0", "1"]} means task 2 depends on tasks 0 and 1
+
+The tool executes tasks in batches based on dependency order.
+Tasks with no unmet dependencies run in parallel."""
+
+    @property
+    def parameters(self) -> Dict[str, Any]:
+        return {
+            "tasks": {
+                "type": "array",
+                "description": "List of task descriptions to execute",
+                "items": {"type": "string"},
+            },
+            "dependencies": {
+                "type": "object",
+                "description": "Map of task index to array of dependency indices",
+                "additionalProperties": {
+                    "type": "array",
+                    "items": {"type": "string"},
+                },
+                "default": {},
+            },
+        }
+
+    def to_anthropic_schema(self) -> Dict[str, Any]:
+        """Convert to Anthropic tool schema format."""
+        return {
+            "name": self.name,
+            "description": self.description,
+            "input_schema": {
+                "type": "object",
+                "properties": self.parameters,
+                "required": ["tasks"],
+            },
+        }
+
+    async def execute(self, tasks: List[str], dependencies: Dict[str, List[str]] = None) -> str:
+        """Execute tasks with dependency awareness.
+
+        Args:
+            tasks: List of task descriptions
+            dependencies: Map of task index to dependency indices
+
+        Returns:
+            Combined results from all tasks
+        """
+        if not tasks:
+            return "Error: No tasks provided"
+
+        dependencies = dependencies or {}
+
+        # Validate dependencies
+        validation_error = self._validate_dependencies(tasks, dependencies)
+        if validation_error:
+            return validation_error
+
+        # Get allowed tools for subtasks
+        subtask_tools = self._get_subtask_tools()
+
+        # Execute tasks in dependency order
+        results = await self._execute_with_dependencies(tasks, dependencies, subtask_tools)
+
+        # Format and return results
+        return self._format_results(tasks, results)
+
+    def _validate_dependencies(
+        self, tasks: List[str], dependencies: Dict[str, List[str]]
+    ) -> str | None:
+        """Validate dependency graph for cycles and invalid references.
+
+        Args:
+            tasks: List of task descriptions
+            dependencies: Dependency mapping
+
+        Returns:
+            Error message if invalid, None if valid
+        """
+        task_count = len(tasks)
+
+        def validate_index(index_str: str, max_val: int) -> int | None:
+            """Validate and convert string index to int. Returns None if invalid."""
+            try:
+                idx = int(index_str)
+                return idx if 0 <= idx < max_val else None
+            except ValueError:
+                return None
+
+        # Check for invalid task indices
+        for task_idx, deps in dependencies.items():
+            if validate_index(task_idx, task_count) is None:
+                return f"Error: Invalid task index {task_idx}"
+
+            for dep in deps:
+                if validate_index(dep, task_count) is None:
+                    return f"Error: Invalid dependency index {dep}"
+
+        # Check for cycles using DFS
+        if self._has_cycle(task_count, dependencies):
+            return "Error: Circular dependency detected in tasks"
+
+        return None
+
+    def _has_cycle(self, task_count: int, dependencies: Dict[str, List[str]]) -> bool:
+        """Detect cycles in dependency graph using DFS.
+
+        Args:
+            task_count: Number of tasks
+            dependencies: Dependency mapping
+
+        Returns:
+            True if cycle exists
+        """
+        # Build adjacency list
+        graph: Dict[int, List[int]] = {i: [] for i in range(task_count)}
+        for task_idx, deps in dependencies.items():
+            idx = int(task_idx)
+            for dep in deps:
+                graph[int(dep)].append(idx)
+
+        # DFS cycle detection
+        WHITE, GRAY, BLACK = 0, 1, 2
+        colors = [WHITE] * task_count
+
+        def dfs(node: int) -> bool:
+            colors[node] = GRAY
+            for neighbor in graph[node]:
+                if colors[neighbor] == GRAY:
+                    return True
+                if colors[neighbor] == WHITE and dfs(neighbor):
+                    return True
+            colors[node] = BLACK
+            return False
+
+        return any(colors[i] == WHITE and dfs(i) for i in range(task_count))
+
+    def _get_subtask_tools(self) -> List[Dict[str, Any]]:
+        """Get filtered tools for subtask execution.
+
+        Returns:
+            List of tool schemas allowed for subtasks
+        """
+        all_tools = self.agent.tool_executor.get_tool_schemas()
+        return [
+            t
+            for t in all_tools
+            if t.get("name") in ALLOWED_SUBTASK_TOOLS
+            or t.get("function", {}).get("name") in ALLOWED_SUBTASK_TOOLS
+        ]
+
+    async def _execute_with_dependencies(
+        self,
+        tasks: List[str],
+        dependencies: Dict[str, List[str]],
+        tools: List[Dict[str, Any]],
+    ) -> Dict[int, str]:
+        """Execute tasks respecting dependency order.
+
+        Args:
+            tasks: List of task descriptions
+            dependencies: Dependency mapping
+            tools: Available tools for subtasks
+
+        Returns:
+            Dict mapping task index to result
+        """
+        results: Dict[int, str] = {}
+        completed: Set[int] = set()
+        task_count = len(tasks)
+
+        # Convert dependencies to int keys
+        deps: Dict[int, Set[int]] = {}
+        for task_idx, dep_list in dependencies.items():
+            deps[int(task_idx)] = {int(d) for d in dep_list}
+
+        while len(completed) < task_count:
+            # Find tasks ready to execute (no unmet dependencies)
+            ready = []
+            for i in range(task_count):
+                if i not in completed:
+                    task_deps = deps.get(i, set())
+                    if task_deps.issubset(completed):
+                        ready.append(i)
+
+            if not ready:
+                # No progress possible - should not happen after cycle check
+                break
+
+            # Limit batch size
+            batch = ready[: self.MAX_PARALLEL_TASKS]
+
+            # Execute batch in parallel
+            batch_results = await self._execute_batch(batch, tasks, tools, results)
+
+            # Update results and completed set
+            for idx, result in batch_results.items():
+                results[idx] = result
+                completed.add(idx)
+
+        return results
+
+    async def _execute_batch(
+        self,
+        batch: List[int],
+        tasks: List[str],
+        tools: List[Dict[str, Any]],
+        previous_results: Dict[int, str],
+    ) -> Dict[int, str]:
+        """Execute a batch of tasks in parallel.
+
+        Args:
+            batch: List of task indices to execute
+            tasks: Full task list
+            tools: Available tools
+            previous_results: Results from completed tasks
+
+        Returns:
+            Dict mapping task index to result
+        """
+
+        async def execute_single(idx: int) -> tuple:
+            task_desc = tasks[idx]
+            try:
+                result = await self._execute_single_task(idx, task_desc, tools, previous_results)
+                return idx, result
+            except asyncio.CancelledError:
+                raise
+            except Exception as e:
+                return idx, f"Task failed: {str(e)}"
+
+        # Since execute_single catches all exceptions internally (except CancelledError),
+        # any ExceptionGroup raised here indicates cancellation which should propagate
+        results = {}
+        async with asyncio.TaskGroup() as tg:
+            task_list = [tg.create_task(execute_single(idx)) for idx in batch]
+
+        for task in task_list:
+            idx, result = task.result()
+            results[idx] = result
+
+        return results
+
+    async def _execute_single_task(
+        self,
+        idx: int,
+        task_desc: str,
+        tools: List[Dict[str, Any]],
+        previous_results: Dict[int, str],
+    ) -> str:
+        """Execute a single task using isolated mini-loop.
+
+        Args:
+            idx: Task index
+            task_desc: Task description
+            tools: Available tools
+            previous_results: Results from completed tasks
+
+        Returns:
+            Task result string
+        """
+        # Build context from previous results
+        context = self._build_task_context(previous_results)
+
+        # Build task prompt
+        prompt = f"""<role>
+You are executing a subtask as part of a larger parallel execution.
+Focus on completing this specific task efficiently.
+</role>
+
+<task>
+Task #{idx}: {task_desc}
+</task>
+
+{context}
+
+<instructions>
+1. Execute the task using available tools
+2. Focus ONLY on completing this specific task
+3. Provide a clear summary of what was accomplished
+4. Do NOT try to execute other tasks
+</instructions>
+
+Execute the task now:"""
+
+        messages = [LLMMessage(role="user", content=prompt)]
+
+        # Run in isolated context
+        result = await self.agent._react_loop(
+            messages=messages,
+            tools=tools,
+            use_memory=False,
+            save_to_memory=False,
+        )
+
+        return result
+
+    def _build_task_context(self, previous_results: Dict[int, str]) -> str:
+        """Build context string from previous task results.
+
+        Args:
+            previous_results: Results from completed tasks
+
+        Returns:
+            Context string
+        """
+        if not previous_results:
+            return ""
+
+        parts = ["<previous_results>"]
+        for idx, result in sorted(previous_results.items()):
+            # Truncate long results
+            truncated = result
+            if len(result) > 500:
+                truncated = result[:500] + "... [truncated]"
+            parts.append(f"Task #{idx}:\n{truncated}\n")
+        parts.append("</previous_results>")
+
+        return "\n".join(parts)
+
+    def _format_results(self, tasks: List[str], results: Dict[int, str]) -> str:
+        """Format all task results into a combined summary.
+
+        Args:
+            tasks: Original task list
+            results: Dict mapping task index to result
+
+        Returns:
+            Formatted combined results
+        """
+        parts = ["# Parallel Execution Results\n"]
+
+        for idx, task_desc in enumerate(tasks):
+            result = results.get(idx, "Not executed")
+
+            # Truncate long results
+            if len(result) > self.MAX_RESULT_CHARS:
+                result = result[: self.MAX_RESULT_CHARS] + "... [truncated]"
+
+            status = "Completed" if idx in results else "Failed"
+            parts.append(f"## Task {idx}: {task_desc[:100]}\n**Status:** {status}\n{result}\n")
+
+        return "\n".join(parts)

tools/session_manager.py

@@ -0,0 +1,205 @@
+#!/usr/bin/env python3
+"""CLI tool for managing memory sessions.
+
+Usage:
+    python tools/session_manager.py list
+    python tools/session_manager.py show <session_id>
+    python tools/session_manager.py delete <session_id>
+    python tools/session_manager.py stats <session_id>
+"""
+
+import argparse
+import asyncio
+import sys
+from datetime import datetime
+from pathlib import Path
+
+# Add parent directory to path
+sys.path.insert(0, str(Path(__file__).parent.parent))
+
+from memory.store import YamlFileMemoryStore
+from utils.runtime import get_sessions_dir
+
+
+def format_timestamp(ts: str) -> str:
+    """Format ISO timestamp to readable string."""
+    try:
+        dt = datetime.fromisoformat(ts)
+        return dt.strftime("%Y-%m-%d %H:%M:%S")
+    except ValueError:
+        return ts
+
+
+async def list_sessions(store: YamlFileMemoryStore, limit: int = 50):
+    """List all sessions."""
+    sessions = await store.list_sessions(limit=limit)
+
+    if not sessions:
+        print("No sessions found.")
+        return
+
+    print(f"\n📚 Sessions (showing {len(sessions)}):")
+    print("=" * 100)
+    print(f"{'Session ID':<38} {'Updated':<20} {'Messages':<10} {'Preview':<30}")
+    print("-" * 100)
+
+    for session in sessions:
+        session_id = session["id"]
+        updated = format_timestamp(session.get("updated_at", session.get("created_at", "")))
+        msg_count = session["message_count"]
+        preview = session.get("preview", "")[:30]
+
+        print(f"{session_id:<38} {updated:<20} {msg_count:<10} {preview:<30}")
+
+    print("=" * 100)
+
+
+async def show_session(store: YamlFileMemoryStore, session_id: str, show_messages: bool = False):
+    """Show detailed session information."""
+    session_data = await store.load_session(session_id)
+
+    if not session_data:
+        print(f"❌ Session {session_id} not found")
+        return
+
+    stats = session_data["stats"]
+
+    print(f"\n📋 Session: {session_id}")
+    print("=" * 100)
+
+    # Stats
+    print("\n📊 Statistics:")
+    print(f"  Created: {format_timestamp(stats['created_at'])}")
+    print(f"  System Messages: {len(session_data['system_messages'])}")
+    print(f"  Messages: {len(session_data['messages'])}")
+
+    # Messages (if requested)
+    if show_messages and session_data["messages"]:
+        print(f"\n💬 Messages ({len(session_data['messages'])}):")
+        for i, msg in enumerate(session_data["messages"], 1):
+            role = msg.role
+            content = str(msg.content)
+            if len(content) > 100:
+                content = content[:100] + "..."
+
+            print(f"\n  Message {i} [{role}]:")
+            print(f"    {content}")
+
+    print("=" * 100)
+
+
+async def show_stats(store: YamlFileMemoryStore, session_id: str):
+    """Show session statistics."""
+    stats = await store.get_session_stats(session_id)
+
+    if not stats:
+        print(f"❌ Session {session_id} not found")
+        return
+
+    print(f"\n📊 Session Statistics: {session_id}")
+    print("=" * 80)
+
+    print("\n⏰ Timing:")
+    print(f"  Created: {format_timestamp(stats['created_at'])}")
+    if stats.get("updated_at"):
+        print(f"  Updated: {format_timestamp(stats['updated_at'])}")
+
+    print("\n📨 Messages:")
+    print(f"  System Messages: {stats['system_message_count']}")
+    print(f"  Regular Messages: {stats['message_count']}")
+    print(f"  Total Messages: {stats['system_message_count'] + stats['message_count']}")
+
+    print("\n🎫 Tokens:")
+    print(f"  Message Tokens: {stats['total_message_tokens']:,}")
+
+    print("=" * 80)
+
+
+async def delete_session(store: YamlFileMemoryStore, session_id: str, confirm: bool = False):
+    """Delete a session."""
+    if not confirm:
+        response = input(f"Are you sure you want to delete session {session_id}? (yes/no): ")
+        if response.lower() not in ["yes", "y"]:
+            print("Cancelled.")
+            return
+
+    success = await store.delete_session(session_id)
+    if success:
+        print(f"✅ Session {session_id} deleted")
+    else:
+        print(f"❌ Session {session_id} not found")
+
+
+async def main():
+    parser = argparse.ArgumentParser(
+        description="Manage memory sessions",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Examples:
+  List all sessions:
+    python tools/session_manager.py list
+
+  Show session details:
+    python tools/session_manager.py show <session_id>
+
+  Show session with messages:
+    python tools/session_manager.py show <session_id> --messages
+
+  Show session statistics:
+    python tools/session_manager.py stats <session_id>
+
+  Delete a session:
+    python tools/session_manager.py delete <session_id>
+        """,
+    )
+
+    parser.add_argument(
+        "--sessions-dir",
+        type=str,
+        default=None,
+        help="Path to sessions directory (default: .aloop/sessions/)",
+    )
+
+    subparsers = parser.add_subparsers(dest="command", help="Command to run")
+
+    # List command
+    list_parser = subparsers.add_parser("list", help="List all sessions")
+    list_parser.add_argument("--limit", type=int, default=50, help="Max sessions to show")
+
+    # Show command
+    show_parser = subparsers.add_parser("show", help="Show session details")
+    show_parser.add_argument("session_id", help="Session ID")
+    show_parser.add_argument("--messages", action="store_true", help="Show messages")
+
+    # Stats command
+    stats_parser = subparsers.add_parser("stats", help="Show session statistics")
+    stats_parser.add_argument("session_id", help="Session ID")
+
+    # Delete command
+    delete_parser = subparsers.add_parser("delete", help="Delete a session")
+    delete_parser.add_argument("session_id", help="Session ID")
+    delete_parser.add_argument("--yes", action="store_true", help="Skip confirmation")
+
+    args = parser.parse_args()
+
+    if not args.command:
+        parser.print_help()
+        return
+
+    # Initialize store
+    sessions_dir = args.sessions_dir if args.sessions_dir else get_sessions_dir()
+    store = YamlFileMemoryStore(sessions_dir=sessions_dir)
+
+    # Execute command
+    if args.command == "list":
+        await list_sessions(store, limit=args.limit)
+    elif args.command == "show":
+        await show_session(store, args.session_id, show_messages=args.messages)
+    elif args.command == "stats":
+        await show_stats(store, args.session_id)
+    elif args.command == "delete":
+        await delete_session(store, args.session_id, confirm=args.yes)
+
+
+if __name__ == "__main__":
+    asyncio.run(main())