sudosu 0.1.5__py3-none-any.whl

sudosu/core/session.py

@@ -0,0 +1,205 @@
+"""Session management for conversation continuity with SHARED thread model.
+
+This module tracks conversation sessions to enable memory continuity
+with the backend. All agents in a session share the SAME thread_id,
+enabling seamless handoffs where sub-agents see the full conversation
+context.
+
+Key concepts:
+- session_id: Unique ID for this CLI instance
+- thread_id: SAME as session_id (shared across all agents)
+- active_agent: The agent currently handling the conversation
+"""
+
+import time
+import uuid
+from dataclasses import dataclass, field
+from typing import Optional
+
+
+@dataclass
+class ConversationSession:
+    """Tracks a SHARED conversation session across all agents."""
+    
+    session_id: str
+    thread_id: str
+    created_at: float = field(default_factory=time.time)
+    last_activity: float = field(default_factory=time.time)
+    message_count: int = 0
+    active_agent: str = "sudosu"
+    is_routed: bool = False
+    
+    def touch(self):
+        """Update last activity and increment message count."""
+        self.last_activity = time.time()
+        self.message_count += 1
+    
+    @property
+    def duration_seconds(self) -> float:
+        """Get the duration of this conversation in seconds."""
+        return self.last_activity - self.created_at
+    
+    @property
+    def is_active(self) -> bool:
+        """Check if conversation has been active recently (within 30 minutes)."""
+        return (time.time() - self.last_activity) < 1800
+
+
+class SessionManager:
+    """Manages conversation sessions with SHARED thread model.
+    
+    Key concepts:
+    - session_id: Unique ID for this CLI instance
+    - thread_id: SAME as session_id (shared across all agents)
+    - active_agent: The agent currently handling the conversation
+    
+    All agents share the same conversation thread, enabling seamless
+    handoffs where sub-agents see the full context of what was discussed
+    with the orchestrator.
+    """
+    
+    def __init__(self):
+        """Initialize session manager with unique session ID."""
+        # Unique ID for this CLI session
+        self.session_id = str(uuid.uuid4())
+        # SHARED THREAD: Single thread for the entire session
+        self.thread_id = self.session_id
+        # Track which agent is currently active
+        self.active_agent: str = "sudosu"  # Default to orchestrator
+        # Track if we're in a routed conversation
+        self.is_routed: bool = False
+        # Message count for the shared conversation
+        self.message_count: int = 0
+        # Session creation time
+        self.created_at: float = time.time()
+        # Last activity time
+        self.last_activity: float = time.time()
+    
+    def get_thread_id(self) -> str:
+        """Get the shared thread ID for this session.
+        
+        All agents use the same thread_id to share conversation history.
+        """
+        return self.thread_id
+    
+    def set_active_agent(self, agent_name: str, via_routing: bool = False):
+        """Set the currently active agent.
+        
+        Args:
+            agent_name: Name of the agent now handling the conversation
+            via_routing: True if this was set via routing from sudosu
+        """
+        self.active_agent = agent_name
+        self.is_routed = via_routing
+    
+    def get_active_agent(self) -> str:
+        """Get the currently active agent."""
+        return self.active_agent or "sudosu"
+    
+    def reset_to_orchestrator(self):
+        """Reset back to the default sudosu orchestrator."""
+        self.active_agent = "sudosu"
+        self.is_routed = False
+    
+    def increment_message_count(self):
+        """Increment the shared message count and update activity."""
+        self.message_count += 1
+        self.last_activity = time.time()
+    
+    def clear_session(self) -> str:
+        """Clear the session by generating a new thread_id.
+        
+        This starts a fresh conversation for all agents while keeping
+        the same session_id.
+        
+        Returns:
+            New thread_id for the fresh conversation
+        """
+        # Create new thread with unique suffix to start fresh
+        self.thread_id = f"{self.session_id}:{uuid.uuid4().hex[:8]}"
+        self.message_count = 0
+        self.active_agent = "sudosu"
+        self.is_routed = False
+        self.last_activity = time.time()
+        return self.thread_id
+    
+    def get_stats(self) -> dict:
+        """Get statistics about current session.
+        
+        Returns:
+            Dict with session statistics
+        """
+        duration = time.time() - self.created_at
+        return {
+            "session_id": self.session_id,
+            "thread_id": self.thread_id,
+            "active_agent": self.active_agent,
+            "is_routed": self.is_routed,
+            "message_count": self.message_count,
+            "duration_seconds": duration,
+        }
+    
+    # Legacy compatibility methods
+    def get_or_create_conversation(self, agent_name: str) -> "SessionManager":
+        """Legacy method - returns self since we use shared thread.
+        
+        This maintains compatibility with existing code that expects
+        a conversation object.
+        """
+        # Update active agent tracking
+        self.set_active_agent(agent_name)
+        return self
+    
+    def clear_conversation(self, agent_name: str) -> Optional[str]:
+        """Clear the shared conversation.
+        
+        Since all agents share the same thread, this clears everything.
+        The agent_name is kept for backward compatibility.
+        """
+        return self.clear_session()
+    
+    def clear_all_conversations(self) -> int:
+        """Clear the shared conversation.
+        
+        Returns 1 since there's only one shared conversation.
+        """
+        self.clear_session()
+        return 1
+    
+    def get_active_conversation(self) -> Optional["SessionManager"]:
+        """Get the current session (self) for compatibility."""
+        return self if self.message_count > 0 else None
+    
+    @property
+    def conversations(self) -> dict:
+        """Legacy property - returns dict with self if active."""
+        if self.message_count > 0:
+            return {self.active_agent: self}
+        return {}
+    
+    @property
+    def agent_name(self) -> str:
+        """Legacy property for compatibility."""
+        return self.active_agent
+
+
+# Global session manager instance
+_session_manager: Optional[SessionManager] = None
+
+
+def get_session_manager() -> SessionManager:
+    """Get or create the global session manager.
+    
+    Returns:
+        The global SessionManager instance
+    """
+    global _session_manager
+    if _session_manager is None:
+        _session_manager = SessionManager()
+    return _session_manager
+
+
+def reset_session_manager():
+    """Reset the global session manager (useful for testing)."""
+    global _session_manager
+    _session_manager = None

sudosu/tools/__init__.py

@@ -0,0 +1,373 @@
+"""Local tool execution for Sudosu client."""
+
+import fnmatch
+import os
+import subprocess
+from pathlib import Path
+from typing import Any
+
+
+# Special routing result marker
+ROUTING_MARKER = "_sudosu_routing"
+
+# Special consultation routing marker
+CONSULTATION_ROUTING_MARKER = "_sudosu_consultation_route"
+
+
+async def execute_tool(tool_name: str, args: dict, cwd: str) -> dict:
+    """
+    Execute a tool locally and return the result.
+    
+    Args:
+        tool_name: Name of the tool to execute
+        args: Tool arguments
+        cwd: Current working directory
+    
+    Returns:
+        Tool execution result
+    """
+    executors = {
+        "write_file": tool_write_file,
+        "read_file": tool_read_file,
+        "list_directory": tool_list_directory,
+        "run_command": tool_run_command,
+        "search_files": tool_search_files,
+        "route_to_agent": tool_route_to_agent,
+        "consult_orchestrator": tool_consult_orchestrator,
+    }
+    
+    executor = executors.get(tool_name)
+    if not executor:
+        return {"error": f"Unknown tool: {tool_name}"}
+    
+    return await executor(args, cwd)
+
+
+async def tool_consult_orchestrator(args: dict, cwd: str) -> dict:  # noqa: ARG001
+    """
+    Handle consultation with the orchestrator.
+    
+    Note: This is a stub - actual consultation is handled by the backend.
+    The backend intercepts this tool call and evaluates the consultation
+    before returning a decision.
+    
+    Args:
+        args: {"situation": str, "user_request": str}
+        cwd: Current working directory (unused)
+    
+    Returns:
+        Consultation result (handled by backend)
+    """
+    # This should not be reached - backend handles this tool
+    return {
+        "output": "Consultation handled by backend",
+    }
+
+
+async def tool_route_to_agent(args: dict, cwd: str) -> dict:  # noqa: ARG001
+    """
+    Handle routing to another agent.
+    
+    This returns a special marker that the CLI intercepts to perform
+    the actual agent handoff.
+    
+    Args:
+        args: {"agent_name": str, "message": str}
+        cwd: Current working directory (unused for routing)
+    
+    Returns:
+        Special routing result with marker
+    """
+    agent_name = args.get("agent_name")
+    message = args.get("message", "")
+    
+    if not agent_name:
+        return {"error": "Missing 'agent_name' argument"}
+    
+    # Return special routing marker that CLI will intercept
+    # The output message must clearly indicate completion to prevent
+    # the LLM from calling route_to_agent again in a loop
+    return {
+        ROUTING_MARKER: True,
+        "agent_name": agent_name,
+        "message": message,
+        "output": f"SUCCESS: Request has been routed to @{agent_name}. The handoff is complete. Do not call route_to_agent again. Simply confirm the routing to the user and stop.",
+    }
+
+
+def _validate_path(path: str, cwd: str) -> tuple[bool, str, Path]:
+    """
+    Validate that a path is within the allowed directory.
+    
+    Returns:
+        Tuple of (is_valid, error_message, resolved_path)
+    """
+    try:
+        cwd_path = Path(cwd).resolve()
+        full_path = (cwd_path / path).resolve()
+        
+        # Check if path is within cwd
+        full_path.relative_to(cwd_path)
+        
+        return True, "", full_path
+    except ValueError:
+        return False, "Path must be within current directory", Path()
+    except Exception as e:
+        return False, str(e), Path()
+
+
+async def tool_write_file(args: dict, cwd: str) -> dict:
+    """
+    Write content to a file.
+    
+    Args:
+        args: {"file_path": str or "path": str, "content": str}
+        cwd: Current working directory
+    
+    Returns:
+        Result dict with success status
+    """
+    # Support both file_path (backend) and path (legacy) naming
+    path = args.get("file_path") or args.get("path")
+    content = args.get("content")
+    
+    if not path:
+        return {"error": "Missing 'path' argument"}
+    if content is None:
+        return {"error": "Missing 'content' argument"}
+    
+    # Validate path
+    is_valid, error, full_path = _validate_path(path, cwd)
+    if not is_valid:
+        return {"error": error}
+    
+    try:
+        # Create parent directories if needed
+        full_path.parent.mkdir(parents=True, exist_ok=True)
+        
+        # Write file
+        with open(full_path, "w", encoding="utf-8") as f:
+            f.write(content)
+        
+        return {
+            "success": True,
+            "path": str(full_path),
+            "message": f"File written successfully: {path}",
+            "output": f"File written successfully: {path}",
+        }
+    except PermissionError:
+        return {"error": f"Permission denied: {path}", "output": f"Error: Permission denied: {path}"}
+    except Exception as e:
+        return {"error": f"Failed to write file: {e}", "output": f"Error: Failed to write file: {e}"}
+
+
+async def tool_read_file(args: dict, cwd: str) -> dict:
+    """
+    Read content from a file.
+    
+    Args:
+        args: {"file_path": str or "path": str}
+        cwd: Current working directory
+    
+    Returns:
+        Result dict with file content
+    """
+    # Support both file_path (backend) and path (legacy) naming
+    path = args.get("file_path") or args.get("path")
+    
+    if not path:
+        return {"error": "Missing 'path' argument"}
+    
+    # Validate path
+    is_valid, error, full_path = _validate_path(path, cwd)
+    if not is_valid:
+        return {"error": error}
+    
+    if not full_path.exists():
+        return {"error": f"File not found: {path}"}
+    
+    if not full_path.is_file():
+        return {"error": f"Not a file: {path}"}
+    
+    try:
+        with open(full_path, "r", encoding="utf-8") as f:
+            content = f.read()
+        
+        return {
+            "success": True,
+            "content": content,
+            "path": str(full_path),
+            "output": content,
+        }
+    except PermissionError:
+        return {"error": f"Permission denied: {path}", "output": f"Error: Permission denied: {path}"}
+    except UnicodeDecodeError:
+        return {"error": f"Cannot read file (binary?): {path}", "output": f"Error: Cannot read file (binary?): {path}"}
+    except Exception as e:
+        return {"error": f"Failed to read file: {e}", "output": f"Error: Failed to read file: {e}"}
+
+
+async def tool_list_directory(args: dict, cwd: str) -> dict:
+    """
+    List directory contents.
+    
+    Args:
+        args: {"directory_path": str or "path": str} (optional, defaults to ".")
+        cwd: Current working directory
+    
+    Returns:
+        Result dict with directory listing
+    """
+    # Support both directory_path (backend) and path (legacy) naming
+    path = args.get("directory_path") or args.get("path", ".")
+    
+    # Validate path
+    is_valid, error, full_path = _validate_path(path, cwd)
+    if not is_valid:
+        return {"error": error}
+    
+    if not full_path.exists():
+        return {"error": f"Directory not found: {path}"}
+    
+    if not full_path.is_dir():
+        return {"error": f"Not a directory: {path}"}
+    
+    try:
+        items = []
+        for item in sorted(full_path.iterdir()):
+            items.append({
+                "name": item.name,
+                "type": "dir" if item.is_dir() else "file",
+                "size": item.stat().st_size if item.is_file() else None,
+            })
+        
+        # Format output as a listing
+        output_lines = []
+        for item in items:
+            prefix = "[DIR]" if item["type"] == "dir" else "[FILE]"
+            output_lines.append(f"{prefix} {item['name']}")
+        
+        return {
+            "success": True,
+            "path": str(full_path),
+            "items": items,
+            "output": "\n".join(output_lines) if output_lines else "Empty directory",
+        }
+    except PermissionError:
+        return {"error": f"Permission denied: {path}", "output": f"Error: Permission denied: {path}"}
+    except Exception as e:
+        return {"error": f"Failed to list directory: {e}", "output": f"Error: Failed to list directory: {e}"}
+
+
+async def tool_run_command(args: dict, cwd: str) -> dict:
+    """
+    Run a shell command (with restrictions).
+    
+    Args:
+        args: {"command": str}
+        cwd: Current working directory
+    
+    Returns:
+        Result dict with command output
+    """
+    command = args.get("command")
+    
+    if not command:
+        return {"error": "Missing 'command' argument"}
+    
+    # Restricted commands for safety
+    blocked_patterns = [
+        "rm -rf /",
+        "sudo",
+        "> /dev/",
+        "mkfs",
+        "dd if=",
+    ]
+    
+    for pattern in blocked_patterns:
+        if pattern in command:
+            return {
+                "error": f"Command blocked for safety: contains '{pattern}'",
+                "output": f"Error: Command blocked for safety: contains '{pattern}'",
+            }
+    
+    try:
+        result = subprocess.run(
+            command,
+            shell=True,
+            capture_output=True,
+            text=True,
+            timeout=60,
+            cwd=cwd,
+            check=False,
+        )
+        
+        # Combine stdout and stderr for output
+        output = result.stdout
+        if result.stderr:
+            output += f"\n[stderr]: {result.stderr}"
+        
+        return {
+            "success": result.returncode == 0,
+            "stdout": result.stdout,
+            "stderr": result.stderr,
+            "returncode": result.returncode,
+            "output": output.strip() if output else "(no output)",
+        }
+    except subprocess.TimeoutExpired:
+        return {"error": "Command timed out (60s limit)", "output": "Error: Command timed out (60s limit)"}
+    except Exception as e:
+        return {"error": f"Failed to run command: {e}", "output": f"Error: Failed to run command: {e}"}
+
+
+async def tool_search_files(args: dict, cwd: str) -> dict:
+    """
+    Search for files matching a pattern.
+    
+    Args:
+        args: {"pattern": str, "directory": str (optional)}
+        cwd: Current working directory
+    
+    Returns:
+        Result dict with matching files
+    """
+    pattern = args.get("pattern")
+    directory = args.get("directory", ".")
+    
+    if not pattern:
+        return {"error": "Missing 'pattern' argument"}
+    
+    # Validate path
+    is_valid, error, full_path = _validate_path(directory, cwd)
+    if not is_valid:
+        return {"error": error}
+    
+    if not full_path.exists():
+        return {"error": f"Directory not found: {directory}"}
+    
+    if not full_path.is_dir():
+        return {"error": f"Not a directory: {directory}"}
+    
+    try:
+        matches = []
+        # Use glob for ** patterns, fnmatch for simple patterns
+        if "**" in pattern:
+            for match in full_path.glob(pattern):
+                matches.append(str(match.relative_to(full_path)))
+        else:
+            for root, dirs, files in os.walk(full_path):
+                for filename in files:
+                    if fnmatch.fnmatch(filename, pattern):
+                        rel_path = os.path.relpath(os.path.join(root, filename), full_path)
+                        matches.append(rel_path)
+        
+        return {
+            "success": True,
+            "matches": matches,
+            "count": len(matches),
+            "output": "\n".join(matches) if matches else "No matches found",
+        }
+    except PermissionError:
+        return {"error": f"Permission denied: {directory}"}
+    except OSError as e:
+        return {"error": f"Failed to search: {e}"}