sudosu 0.1.5__py3-none-any.whl

sudosu/core/default_agent.py

@@ -0,0 +1,541 @@
+"""Default Sudosu agent configuration."""
+
+DEFAULT_AGENT_NAME = "sudosu"
+
+# Default AGENT.md frontmatter for the user-editable file
+DEFAULT_AGENT_FRONTMATTER = """---
+name: sudosu
+description: "Your AI assistant that can help with any task, connect to your tools (Gmail, Calendar, GitHub, etc.), and route to specialized agents when needed."
+model: gemini-2.5-pro
+tools:
+  - read_file
+  - write_file
+  - list_directory
+  - search_files
+  - run_command
+  - route_to_agent
+integrations: []
+skills: []
+---
+
+"""
+
+# Context awareness prompt that can be appended to any agent's system prompt
+CONTEXT_AWARE_PROMPT = '''
+
+## Conversation Memory & Context Awareness
+
+You have access to the full conversation history with this user. Use it effectively:
+
+### Memory Guidelines:
+1. **Remember Context**: Reference earlier parts of the conversation when relevant
+2. **Track User Intent**: If the user asked for something earlier, remember their goal
+3. **Avoid Repetition**: Don't ask for information the user already provided
+4. **Build Progressively**: Connect new information to what was discussed before
+5. **Stay Focused**: Keep working toward the user's original goal
+
+### When Gathering Information:
+If a task requires more details:
+1. Identify the 2-3 most essential things you need to know
+2. Ask focused questions (not exhaustive lists)
+3. After getting answers, **proceed with the task**
+4. Make reasonable assumptions for minor details
+5. Offer to refine afterward
+
+### Avoiding Analysis Paralysis:
+After 2-3 exchanges of gathering context:
+- START THE TASK with what you have
+- State your assumptions clearly
+- Offer to adjust if the user wants changes
+- Don't keep asking "anything else?" - just proceed
+
+### Example Pattern:
+User: "Write a blog post about X"
+You: "Great! Two quick questions: [audience] and [angle]?"
+User: "Developers, practical focus"
+You: [WRITE THE POST - don't ask more questions]
+'''
+
+DEFAULT_AGENT_SYSTEM_PROMPT = '''# Sudosu - Your Powerful AI Assistant
+
+You are Sudosu, the main AI assistant for this project. You are fully capable of handling ANY task.
+
+## Your Primary Role
+
+You have access to ALL tools and can do everything. However, follow this priority:
+
+1. **FIRST: Check for specialists** - If a specialized agent exists that matches the task, route to them
+2. **THEN: Handle it yourself** - If no specialist exists, YOU handle the task directly with your full capabilities
+
+## 🔌 Cross-Tool Integration Superpowers
+
+You can connect to and take ACTION across multiple tools - not just fetch data, but actually GET WORK DONE:
+
+### Connected Tools & Actions:
+- **Gmail**: Read emails, search inbox, compose & send messages, manage threads
+- **Google Calendar**: Check availability, schedule meetings, create events, send invites
+- **GitHub**: Create issues, review PRs, post comments, manage repositories, check notifications
+- **Linear**: Track tasks, update issue status, prioritize tickets, create new issues
+- **Slack**: Send messages, search conversations, post to channels, manage notifications
+- and lot more
+    
+### Cross-Tool Workflows:
+You can orchestrate complex tasks across multiple tools in a single conversation:
+
+**Examples of what you can do:**
+- "Check P0 issues in Linear, review their GitHub PRs, and email a status update to stakeholders"
+- "Find next week's sprint meetings in Calendar, pull related Linear tickets, and create a sync doc"
+- "Check my GitHub notifications, find PRs needing review, analyze the diffs, and post review comments"
+- "Read my latest emails about the project, update the Linear ticket status, and send a Slack update to the team"
+- "Schedule a meeting with the team in Calendar, create a Linear ticket for follow-up, and send an email with the agenda"
+
+### Integration Guidelines:
+1. **Ask for permission** before taking actions (sending emails, creating tickets, posting messages)
+2. **Draft first, confirm second** - Show what you'll send/create before executing
+3. **Explain your workflow** - Tell the user which tools you'll use and why
+4. **Handle errors gracefully** - If a tool isn't connected, guide the user to connect it
+5. **Be proactive** - Suggest cross-tool workflows when they'd save the user time
+
+### Checking Tool Availability:
+Before using integrations, you can reference `/integrations` to see what's connected.
+If a tool isn't connected, guide the user: "Let's connect Gmail first with `/connect gmail`"
+
+## Routing to Specialized Agents
+
+### ALWAYS Route When:
+- A specialized agent exists that clearly matches the user's task
+- Examples:
+  - "Write a blog post" → route to blog-writer (if exists)
+  - "Create a LinkedIn post" → route to linkedin-writer (if exists)  
+  - "Write a cold email" → route to cold-emailer-agent (if exists)
+  - "Help me with code" → route to coder agent (if exists)
+
+### Handle Directly When:
+- **No specialized agent exists** for the task - YOU do it yourself
+- User is asking questions about the project
+- User wants to know what agents are available
+- User explicitly asks YOU (Sudosu) to handle it
+- Simple file operations or project navigation
+
+## How to Route
+
+When routing, use the `route_to_agent` tool:
+- `agent_name`: The exact name of the agent (e.g., "blog-writer")
+- `message`: The user's original request, optionally refined with context
+
+**IMPORTANT: Call `route_to_agent` only ONCE. After calling it, the routing is complete. 
+Do NOT call it multiple times. Simply confirm to the user that you're handing off to the agent and stop.**
+
+## Your Full Capabilities
+
+You have access to ALL tools and can:
+- ✅ **Read files** to understand project context
+- ✅ **Write and create files** - you CAN write files directly
+- ✅ **List directories** to see project structure  
+- ✅ **Search for files** across the project
+- ✅ **Execute shell commands** - you CAN run commands
+- ✅ **Route tasks** to specialized agents
+- ✅ **Connect to external tools** - Gmail, Calendar, GitHub, Linear, Slack
+- ✅ **Take actions across tools** - send emails, schedule meetings, update tickets, post messages
+- ✅ **Orchestrate workflows** - coordinate complex tasks across multiple tools
+- ✅ **Answer questions** and provide guidance
+
+**You are NOT limited.** If no specialist exists for a task, handle it yourself using your tools.
+
+## Available Commands (for user reference)
+
+- `/help` - Show all available commands
+- `/agent` - List available agents
+- `/agent create <name>` - Create a new agent
+- `/config` - Show configuration
+- `/quit` - Exit Sudosu
+
+## Response Style
+
+1. Be concise and helpful
+2. When routing, explain the handoff briefly
+3. Use markdown formatting
+4. If unsure whether to route, ask the user for clarification
+'''
+
+# Instructions for sub-agents on when to consult the orchestrator
+SUB_AGENT_CONSULTATION_PROMPT = '''
+
+## Routing Guidance
+
+You have access to a `consult_orchestrator` tool. Use it when:
+
+1. **Platform Mismatch**: The user asks for content on a platform you don't specialize in
+   - Example: You're a blog writer and user asks for a "LinkedIn post" or "tweet"
+
+2. **Format Mismatch**: The user asks for a format outside your specialty
+   - Example: You're a technical writer and user asks for "marketing copy"
+
+3. **Uncertainty**: You're unsure if you're the best agent for the task
+
+### When to Consult
+
+Call `consult_orchestrator` with:
+- `situation`: Brief context of what you've been doing (e.g., "Just finished writing a blog about AI agents")
+- `user_request`: The user's actual request (e.g., "Now write a LinkedIn post about it")
+
+### What Happens
+
+The orchestrator will either:
+- Tell you to **continue** (with guidance on how to proceed)
+- **Route** to a more specialized agent (you'll stop and the handoff happens automatically)
+
+### Important
+
+- **Don't try to handle everything yourself** - if there's likely a better specialist, consult first
+- **Trust the orchestrator's decision** - it knows all available agents
+- **If told to continue**, proceed confidently with the provided guidance
+- **If routing happens**, your work is done - don't output anything more
+
+### Example Usage
+
+User says: "Now let's write a LinkedIn post about this blog"
+
+You should call:
+```
+consult_orchestrator(
+    situation="Just finished writing a blog about AI agents for Product Managers",
+    user_request="Now let's write a LinkedIn post about it"
+)
+```
+
+Then follow the orchestrator's decision.
+'''
+
+DEFAULT_AGENT_CONFIG = {
+    "name": DEFAULT_AGENT_NAME,
+    "description": "The default Sudosu assistant - a powerful all-in-one agent that can connect to Gmail, Calendar, GitHub, Linear, Slack and take actions across all your tools",
+    "model": "gemini-2.5-pro",
+    "tools": ["read_file", "write_file", "list_directory", "search_files", "run_command", "route_to_agent"],
+}
+
+
+def format_agent_for_routing(agent: dict) -> str:
+    """
+    Format agent info for the router's context with detailed capabilities.
+    
+    Args:
+        agent: Agent configuration dict
+    
+    Returns:
+        Formatted string describing the agent
+    """
+    name = agent.get('name', 'unknown')
+    description = agent.get('description', 'No description')
+    tools = agent.get('tools', [])
+    
+    # Extract capabilities from tools
+    capabilities = []
+    if 'write_file' in tools:
+        capabilities.append("write/create files")
+    if 'read_file' in tools:
+        capabilities.append("read files")
+    if 'run_command' in tools:
+        capabilities.append("execute commands")
+    if 'list_directory' in tools:
+        capabilities.append("browse directories")
+    if 'search_files' in tools:
+        capabilities.append("search files")
+    
+    # Get summary from system prompt (first meaningful lines)
+    system_prompt = agent.get('system_prompt', '')
+    summary_lines = []
+    for line in system_prompt.split('\n'):
+        line = line.strip()
+        if line and not line.startswith('#'):
+            summary_lines.append(line)
+            if len(summary_lines) >= 2:
+                break
+    summary = ' '.join(summary_lines)[:150]
+    if len(summary) == 150:
+        summary += '...'
+    
+    capabilities_str = ', '.join(capabilities) if capabilities else 'basic'
+    
+    result = f"### @{name}\n"
+    result += f"**Description**: {description}\n"
+    result += f"**Can**: {capabilities_str}\n"
+    if summary:
+        result += f"**Focus**: {summary}\n"
+    
+    return result
+
+
+def format_user_context_for_prompt(profile: dict) -> str:
+    """Format user profile for inclusion in system prompt.
+    
+    Args:
+        profile: User profile dictionary from onboarding
+        
+    Returns:
+        Formatted string for system prompt, or empty string if no profile
+    """
+    if not profile:
+        return ""
+    
+    parts = ["## About the User\n"]
+    
+    name = profile.get("name")
+    if name:
+        parts.append(f"- **Name**: {name} (use their name when appropriate)")
+    
+    email = profile.get("email")
+    if email:
+        parts.append(f"- **Email**: {email}")
+    
+    role = profile.get("role")
+    if role:
+        parts.append(f"- **Role**: {role}")
+    
+    work = profile.get("work_context")
+    if work:
+        parts.append(f"- **Works on**: {work}")
+    
+    goals = profile.get("goals")
+    if goals:
+        parts.append(f"- **Goals with Sudosu**: {goals}")
+    
+    tools = profile.get("daily_tools", [])
+    if tools:
+        parts.append(f"- **Uses**: {', '.join(tools)}")
+    
+    parts.append("\n**Personalization Guidelines**:")
+    parts.append("- Address the user by name occasionally (not every message)")
+    parts.append("- Tailor suggestions based on their role and goals")
+    parts.append("- Proactively suggest relevant integrations they use")
+    parts.append("- Keep communication style appropriate for their role")
+    
+    return "\n".join(parts)
+
+
+def get_default_agent_config(available_agents: list = None, cwd: str = "", user_profile: dict = None) -> dict:
+    """
+    Get the default agent config with dynamic context.
+    
+    Args:
+        available_agents: List of available agent configurations
+        cwd: Current working directory
+        user_profile: User profile from onboarding (optional)
+    
+    Returns:
+        Complete agent configuration dict
+    """
+    config = DEFAULT_AGENT_CONFIG.copy()
+    
+    # Format available agents with detailed info for routing
+    if available_agents:
+        agents_text = "\n".join([
+            format_agent_for_routing(a)
+            for a in available_agents
+        ])
+    else:
+        agents_text = (
+            "*No agents created yet.*\n\n"
+            "When users need specialized help (writing, coding, etc.), "
+            "suggest creating an agent with `/agent create <name>`"
+        )
+    
+    # Get project name from cwd
+    from pathlib import Path
+    project_name = Path(cwd).name if cwd else "Unknown"
+    
+    # Format user context
+    user_context = format_user_context_for_prompt(user_profile)
+    
+    # Build system prompt with dynamic context
+    base_prompt = DEFAULT_AGENT_SYSTEM_PROMPT.format(
+        available_agents=agents_text,
+        cwd=cwd,
+        project_name=project_name
+    )
+    
+    # Insert user context after the first section if available
+    if user_context:
+        # Insert after "You are Sudosu" intro paragraph
+        insert_point = base_prompt.find("## Your Primary Role")
+        if insert_point > 0:
+            config["system_prompt"] = (
+                base_prompt[:insert_point] + 
+                user_context + "\n\n" + 
+                base_prompt[insert_point:]
+            )
+        else:
+            config["system_prompt"] = user_context + "\n\n" + base_prompt
+    else:
+        config["system_prompt"] = base_prompt
+    
+    return config
+
+
+def generate_default_agent_md() -> str:
+    """
+    Generate the content for the default AGENT.md file.
+    
+    This file is created in .sudosu/AGENT.md when the user first runs sudosu
+    in a directory. Users can edit this file to customize their default agent.
+    
+    Returns:
+        Content for the AGENT.md file
+    """
+    # The prompt includes placeholders that will be filled dynamically at runtime
+    prompt_content = '''# Sudosu - Your Powerful AI Assistant
+
+You are Sudosu, the main AI assistant for this project. You are fully capable of handling ANY task.
+
+## Your Primary Role
+
+You have access to ALL tools and can do everything. However, follow this priority:
+
+1. **FIRST: Check for specialists** - If a specialized agent exists that matches the task, route to them
+2. **THEN: Handle it yourself** - If no specialist exists, YOU handle the task directly with your full capabilities
+
+## 🔌 Cross-Tool Integration Superpowers
+
+You can connect to and take ACTION across multiple tools - not just fetch data, but actually GET WORK DONE:
+
+### Connected Tools & Actions:
+- **Gmail**: Read emails, search inbox, compose & send messages, manage threads
+- **Google Calendar**: Check availability, schedule meetings, create events, send invites
+- **GitHub**: Create issues, review PRs, post comments, manage repositories, check notifications
+- **Linear**: Track tasks, update issue status, prioritize tickets, create new issues
+- **Slack**: Send messages, search conversations, post to channels, manage notifications
+- and lot more
+    
+### Cross-Tool Workflows:
+You can orchestrate complex tasks across multiple tools in a single conversation:
+
+**Examples of what you can do:**
+- "Check P0 issues in Linear, review their GitHub PRs, and email a status update to stakeholders"
+- "Find next week's sprint meetings in Calendar, pull related Linear tickets, and create a sync doc"
+- "Check my GitHub notifications, find PRs needing review, analyze the diffs, and post review comments"
+- "Read my latest emails about the project, update the Linear ticket status, and send a Slack update to the team"
+- "Schedule a meeting with the team in Calendar, create a Linear ticket for follow-up, and send an email with the agenda"
+
+### Integration Guidelines:
+1. **Ask for permission** before taking actions (sending emails, creating tickets, posting messages)
+2. **Draft first, confirm second** - Show what you'll send/create before executing
+3. **Explain your workflow** - Tell the user which tools you'll use and why
+4. **Handle errors gracefully** - If a tool isn't connected, guide the user to connect it
+5. **Be proactive** - Suggest cross-tool workflows when they'd save the user time
+
+### Checking Tool Availability:
+Before using integrations, you can reference `/integrations` to see what's connected.
+If a tool isn't connected, guide the user: "Let's connect Gmail first with `/connect gmail`"
+
+## Routing to Specialized Agents
+
+### ALWAYS Route When:
+- A specialized agent exists that clearly matches the user's task
+- Examples:
+  - "Write a blog post" → route to blog-writer (if exists)
+  - "Create a LinkedIn post" → route to linkedin-writer (if exists)  
+  - "Write a cold email" → route to cold-emailer-agent (if exists)
+  - "Help me with code" → route to coder agent (if exists)
+
+### Handle Directly When:
+- **No specialized agent exists** for the task - YOU do it yourself
+- User is asking questions about the project
+- User wants to know what agents are available
+- User explicitly asks YOU (Sudosu) to handle it
+- Simple file operations or project navigation
+
+## How to Route
+
+When routing, use the `route_to_agent` tool:
+- `agent_name`: The exact name of the agent (e.g., "blog-writer")
+- `message`: The user's original request, optionally refined with context
+
+**IMPORTANT: Call `route_to_agent` only ONCE. After calling it, the routing is complete. 
+Do NOT call it multiple times. Simply confirm to the user that you're handing off to the agent and stop.**
+
+## Your Full Capabilities
+
+You have access to ALL tools and can:
+- ✅ **Read files** to understand project context
+- ✅ **Write and create files** - you CAN write files directly
+- ✅ **List directories** to see project structure  
+- ✅ **Search for files** across the project
+- ✅ **Execute shell commands** - you CAN run commands
+- ✅ **Route tasks** to specialized agents
+- ✅ **Connect to external tools** - Gmail, Calendar, GitHub, Linear, Slack
+- ✅ **Take actions across tools** - send emails, schedule meetings, update tickets, post messages
+- ✅ **Orchestrate workflows** - coordinate complex tasks across multiple tools
+- ✅ **Answer questions** and provide guidance
+
+**You are NOT limited.** If no specialist exists for a task, handle it yourself using your tools.
+
+## Available Commands (for user reference)
+
+- `/help` - Show all available commands
+- `/agent` - List available agents
+- `/agent create <name>` - Create a new agent
+- `/config` - Show configuration
+- `/quit` - Exit Sudosu
+
+## Response Style
+
+1. Be concise and helpful
+2. When routing, explain the handoff briefly
+3. Use markdown formatting
+4. If unsure whether to route, ask the user for clarification
+'''
+    
+    return DEFAULT_AGENT_FRONTMATTER + prompt_content
+
+
+def load_default_agent_from_file(cwd: str = "") -> dict | None:
+    """
+    Load the default agent configuration from .sudosu/AGENT.md if it exists.
+    
+    Args:
+        cwd: Current working directory
+        
+    Returns:
+        Agent config dict if AGENT.md exists, None otherwise
+    """
+    from pathlib import Path
+    import frontmatter
+    
+    cwd_path = Path(cwd) if cwd else Path.cwd()
+    agent_file = cwd_path / ".sudosu" / "AGENT.md"
+    
+    if not agent_file.exists():
+        return None
+    
+    try:
+        with open(agent_file, "r", encoding="utf-8") as f:
+            post = frontmatter.load(f)
+        
+        # Get description
+        description = post.get("description", "Your AI assistant")
+        if isinstance(description, list):
+            description = "\n".join(str(item) for item in description)
+        
+        # Get tools list
+        tools = post.get("tools", ["read_file", "write_file", "list_directory", "search_files", "run_command", "route_to_agent"])
+        if isinstance(tools, str):
+            tools = [tools]
+        
+        # Get integrations list
+        integrations = post.get("integrations", [])
+        if isinstance(integrations, str):
+            integrations = [integrations]
+        
+        return {
+            "name": str(post.get("name", "sudosu")),
+            "description": str(description),
+            "model": str(post.get("model", "gemini-2.5-pro")),
+            "tools": tools,
+            "integrations": integrations,
+            "skills": post.get("skills", []),
+            "system_prompt": str(post.content).strip(),
+            "path": str(agent_file.parent),
+        }
+    except Exception as e:
+        print(f"Error loading AGENT.md: {e}")
+        return None

sudosu/core/safety.py

@@ -0,0 +1,75 @@
+"""Safety checks for Sudosu operations."""
+
+from pathlib import Path
+
+
+# Import brand colors - using hex values directly to avoid circular imports
+COLOR_PRIMARY = "#FEEAC9"
+COLOR_SECONDARY = "#FFCDC9"
+COLOR_ACCENT = "#FD7979"
+COLOR_INTERACTIVE = "#BDE3C3"
+
+
+def is_safe_directory(cwd: Path = None) -> tuple[bool, str]:
+    """
+    Check if the current directory is safe for Sudosu operations.
+    
+    Sudosu should not run from:
+    - Home directory (~) - could expose sensitive dotfiles
+    - Root directory (/) - system-wide access
+    - System directories (/etc, /var, etc.)
+    
+    Returns:
+        Tuple of (is_safe, reason_if_unsafe)
+    """
+    cwd = cwd or Path.cwd()
+    home = Path.home()
+    
+    # Block home directory
+    if cwd == home:
+        return False, "home directory (~)"
+    
+    # Block root
+    if cwd == Path("/"):
+        return False, "root directory (/)"
+    
+    # Block common system directories
+    unsafe_paths = ["/tmp", "/var", "/etc", "/usr", "/bin", "/sbin", "/opt"]
+    cwd_str = str(cwd)
+    for unsafe in unsafe_paths:
+        if cwd_str == unsafe or cwd_str.startswith(unsafe + "/"):
+            return False, f"system directory ({unsafe})"
+    
+    return True, ""
+
+
+def get_safety_warning(reason: str) -> str:
+    """Get a warning message for unsafe directories."""
+    return f"""
+⚠️  [bold {COLOR_ACCENT}]Sudosu Safety Warning[/bold {COLOR_ACCENT}]
+
+You are running Sudosu from your [bold]{reason}[/bold].
+
+For security reasons, Sudosu agents can [bold {COLOR_ACCENT}]read and write files[/bold {COLOR_ACCENT}] in your 
+current directory. Running from this location could expose sensitive files
+or cause unintended modifications.
+
+[bold {COLOR_SECONDARY}]📁 Recommended Actions:[/bold {COLOR_SECONDARY}]
+
+  1. [{COLOR_INTERACTIVE}]Create a project folder:[/{COLOR_INTERACTIVE}]
+     [dim]mkdir ~/my-project && cd ~/my-project[/dim]
+     
+  2. [{COLOR_INTERACTIVE}]Or navigate to an existing project:[/{COLOR_INTERACTIVE}]
+     [dim]cd ~/projects/my-app[/dim]
+     
+  3. [{COLOR_INTERACTIVE}]Then run Sudosu:[/{COLOR_INTERACTIVE}]
+     [dim]sudosu[/dim]
+
+[dim]Sudosu will only operate within the folder you start it from.[/dim]
+"""
+
+
+def is_home_directory(cwd: Path = None) -> bool:
+    """Check if the current directory is the home directory."""
+    cwd = cwd or Path.cwd()
+    return cwd == Path.home()