connectonion 0.5.8__py3-none-any.whl

connectonion/trust.py

@@ -0,0 +1,166 @@
+"""
+Purpose: Factory and coordinator for creating trust verification agents with policies
+LLM-Note:
+  Dependencies: imports from [os, pathlib, typing, trust_agents.py, trust_functions.py] | imported by [agent.py] | tested by [tests/test_trust.py]
+  Data flow: receives trust param from Agent.__init__ → get_default_trust_level() checks CONNECTONION_ENV → create_trust_agent() validates trust param → returns Agent with trust verification tools OR None | trust param can be: None (no trust), str ("open"/"careful"/"strict" levels OR markdown policy OR file path), Path (markdown file), Agent (custom trust agent)
+  State/Effects: reads markdown files if Path/file path provided | checks os.environ for CONNECTONION_ENV and CONNECTONION_TRUST | creates Agent instances with trust_verification_tools from trust_functions.py | no writes or global state
+  Integration: exposes create_trust_agent(trust, api_key, model), get_default_trust_level(), validate_trust_level(level), TRUST_LEVELS constant | used by Agent.__init__ to create self.trust | trust agents get tools from get_trust_verification_tools() and prompts from get_trust_prompt()
+  Performance: lazy creation (only when trust param provided) | environment checks are fast | file I/O only for custom policies
+  Errors: raises TypeError for invalid trust type | raises ValueError for invalid trust level string | raises FileNotFoundError for missing policy files | heuristic detection for ambiguous strings (checks if file exists before treating as inline policy)
+"""
+
+import os
+from pathlib import Path
+from typing import Union, Optional
+
+from .trust_agents import TRUST_PROMPTS, get_trust_prompt
+from .trust_functions import get_trust_verification_tools
+
+
+# Trust level constants
+TRUST_LEVELS = ["open", "careful", "strict"]
+
+
+def get_default_trust_level() -> Optional[str]:
+    """
+    Get default trust level based on environment.
+    
+    Returns:
+        Default trust level or None
+    """
+    env = os.environ.get('CONNECTONION_ENV', '').lower()
+    
+    if env == 'development':
+        return 'open'
+    elif env == 'production':
+        return 'strict'
+    elif env in ['staging', 'test']:
+        return 'careful'
+    
+    return None
+
+
+def create_trust_agent(trust: Union[str, Path, 'Agent', None], api_key: Optional[str] = None, model: str = "gpt-5-mini") -> Optional['Agent']:
+    """
+    Create or return a trust agent based on the trust parameter.
+    
+    Args:
+        trust: Can be:
+            - None: No trust agent (returns None)
+            - str: Trust level ("open", "careful", "strict") or markdown policy/file path
+            - Path: Path to markdown policy file
+            - Agent: Custom trust agent (returned as-is)
+    
+    Returns:
+        An Agent configured for trust verification, or None
+        
+    Raises:
+        TypeError: If trust is not a valid type
+        ValueError: If trust level is invalid
+        FileNotFoundError: If trust policy file doesn't exist
+    """
+    from .agent import Agent  # Import here to avoid circular dependency
+    
+    # If None, check for environment default
+    if trust is None:
+        env_trust = os.environ.get('CONNECTONION_TRUST')
+        if env_trust:
+            trust = env_trust
+        else:
+            return None  # No trust agent
+    
+    # If it's already an Agent, validate and return it
+    if isinstance(trust, Agent):
+        if not trust.tools:
+            raise ValueError("Trust agent must have verification tools")
+        return trust
+    
+    # Get trust verification tools
+    trust_tools = get_trust_verification_tools()
+    
+    # Handle Path object
+    if isinstance(trust, Path):
+        if not trust.exists():
+            raise FileNotFoundError(f"Trust policy file not found: {trust}")
+        policy = trust.read_text(encoding='utf-8')
+        return Agent(
+            name="trust_agent_custom",
+            tools=trust_tools,
+            system_prompt=policy,
+            api_key=api_key,
+            model=model
+        )
+    
+    # Handle string parameter
+    if isinstance(trust, str):
+        trust_lower = trust.lower()
+        
+        # Check if it's a trust level
+        if trust_lower in TRUST_LEVELS:
+            return Agent(
+                name=f"trust_agent_{trust_lower}",
+                tools=trust_tools,
+                system_prompt=get_trust_prompt(trust_lower),
+                api_key=api_key,
+                model=model
+            )
+        
+        # Check if it looks like a trust level but isn't valid
+        # (single word without path separators or newlines)
+        if '\n' not in trust and '/' not in trust and '\\' not in trust and ' ' not in trust and len(trust) < 20:
+            # It's a single word, probably meant to be a trust level
+            if not os.path.exists(trust):  # And it's not a file
+                raise ValueError(f"Invalid trust level: {trust}. Must be one of: {', '.join(TRUST_LEVELS)}")
+        
+        # Check if it's a file path (contains path separators or ends with .md)
+        if '/' in trust or '\\' in trust or trust.endswith('.md'):
+            path = Path(trust)
+            if not path.exists():
+                raise FileNotFoundError(f"Trust policy file not found: {trust}")
+            policy = path.read_text(encoding='utf-8')
+            return Agent(
+                name="trust_agent_custom",
+                tools=trust_tools,
+                system_prompt=policy,
+                api_key=api_key,
+                model=model
+            )
+        
+        # Check if it's a single-line string that could be a file
+        if '\n' not in trust and len(trust) < 100:
+            # Could be a file path without obvious markers
+            path = Path(trust)
+            if path.exists():
+                policy = path.read_text(encoding='utf-8')
+                return Agent(
+                    name="trust_agent_custom",
+                    tools=trust_tools,
+                    system_prompt=policy,
+                    api_key=api_key,
+                    model=model
+                )
+        
+        # It's an inline markdown policy
+        return Agent(
+            name="trust_agent_custom",
+            tools=trust_tools,
+            system_prompt=trust,
+            api_key=api_key,
+            model=model
+        )
+    
+    # Invalid type
+    raise TypeError(f"Trust must be a string (level/policy/path), Path, Agent, or None, not {type(trust).__name__}")
+
+
+def validate_trust_level(level: str) -> bool:
+    """
+    Check if a string is a valid trust level.
+    
+    Args:
+        level: String to check
+        
+    Returns:
+        True if valid trust level, False otherwise
+    """
+    return level.lower() in TRUST_LEVELS

connectonion/trust_agents.py

@@ -0,0 +1,71 @@
+"""
+Purpose: Provide pre-configured system prompts for trust agents at different security levels
+LLM-Note:
+  Dependencies: no imports | imported by [trust.py] | tested by [tests/test_trust.py]
+  Data flow: trust.py calls get_trust_prompt(level) → validates level → returns TRUST_PROMPTS[level] string → used as system_prompt for trust Agent
+  State/Effects: no state or side effects | pure data module | TRUST_PROMPTS dict contains 3 prompts: "open" (dev - trust all), "careful" (staging - basic verification), "strict" (prod - whitelist only)
+  Integration: exposes TRUST_PROMPTS dict, get_trust_prompt(level), get_open_trust_prompt(), get_careful_trust_prompt(), get_strict_trust_prompt() | used by create_trust_agent() in trust.py to configure trust agent behavior
+  Performance: constant-time dict lookup | no computation
+  Errors: raises ValueError if level not in ["open", "careful", "strict"]
+"""
+
+# Default trust prompts for each level
+TRUST_PROMPTS = {
+    "open": """You are an open trust agent for development environments.
+You trust all agents without verification to enable rapid development and testing.
+When asked to verify an agent, always approve it.
+Remember: This is only suitable for development, never for production.""",
+    
+    "careful": """You are a careful trust agent for staging and testing environments.
+You verify agents before trusting them by:
+1. Checking if they can perform their claimed functions
+2. Verifying they respond in reasonable time
+3. Looking for any obvious malicious behavior
+
+Be thorough but not overly restrictive. Allow agents that pass basic verification.""",
+    
+    "strict": """You are a strict trust agent for production environments.
+You enforce maximum security by only trusting pre-approved agents.
+
+Requirements for trust:
+1. Agent MUST be on the whitelist
+2. Agent MUST have valid credentials
+3. Agent MUST come from trusted domains
+4. Agent MUST pass all security checks
+
+Reject any agent that doesn't meet ALL criteria. Security is the top priority."""
+}
+
+
+def get_open_trust_prompt() -> str:
+    """Get the prompt for an open trust agent (development)."""
+    return TRUST_PROMPTS["open"]
+
+
+def get_careful_trust_prompt() -> str:
+    """Get the prompt for a careful trust agent (staging/testing)."""
+    return TRUST_PROMPTS["careful"]
+
+
+def get_strict_trust_prompt() -> str:
+    """Get the prompt for a strict trust agent (production)."""
+    return TRUST_PROMPTS["strict"]
+
+
+def get_trust_prompt(level: str) -> str:
+    """
+    Get the trust prompt for a given level.
+    
+    Args:
+        level: Trust level ("open", "careful", or "strict")
+        
+    Returns:
+        The trust prompt for that level
+        
+    Raises:
+        ValueError: If level is not valid
+    """
+    level_lower = level.lower()
+    if level_lower not in TRUST_PROMPTS:
+        raise ValueError(f"Invalid trust level: {level}. Must be one of: {', '.join(TRUST_PROMPTS.keys())}")
+    return TRUST_PROMPTS[level_lower]

connectonion/trust_functions.py

@@ -0,0 +1,88 @@
+"""
+Purpose: Provide tool functions for trust agents to verify other agents
+LLM-Note:
+  Dependencies: imports from [pathlib, typing] | imported by [trust.py] | tested by [tests/test_trust.py]
+  Data flow: create_trust_agent() calls get_trust_verification_tools() → returns list of [check_whitelist, test_capability, verify_agent] functions → these become tools for trust Agent → trust agent calls tools with agent_id → functions return descriptive strings → AI interprets results per trust policy
+  State/Effects: check_whitelist() reads ~/.connectonion/trusted.txt file if exists | supports wildcard patterns with * | test_capability() and verify_agent() are pure (no I/O, just return descriptive strings for AI)
+  Integration: exposes check_whitelist(agent_id), test_capability(agent_id, test, expected), verify_agent(agent_id, agent_info), get_trust_verification_tools() | used by trust.py to equip trust agents with verification capabilities
+  Performance: file read only for check_whitelist | simple string operations | no network calls
+  Errors: check_whitelist() catches file read exceptions and returns error string | missing whitelist file returns helpful message | no exceptions raised (errors returned as strings for AI interpretation)
+"""
+
+from pathlib import Path
+from typing import List, Callable
+
+
+def check_whitelist(agent_id: str) -> str:
+    """
+    Check if an agent is on the whitelist.
+    
+    Args:
+        agent_id: Identifier of the agent to check
+        
+    Returns:
+        String indicating if agent is whitelisted or not
+    """
+    whitelist_path = Path.home() / ".connectonion" / "trusted.txt"
+    if whitelist_path.exists():
+        try:
+            whitelist = whitelist_path.read_text(encoding='utf-8')
+            lines = whitelist.strip().split('\n')
+            for line in lines:
+                line = line.strip()
+                if not line or line.startswith('#'):
+                    continue
+                if line == agent_id:
+                    return f"{agent_id} is on the whitelist"
+                # Simple wildcard support
+                if '*' in line:
+                    pattern = line.replace('*', '')
+                    if pattern in agent_id:
+                        return f"{agent_id} matches whitelist pattern: {line}"
+            return f"{agent_id} is NOT on the whitelist"
+        except Exception as e:
+            return f"Error reading whitelist: {e}"
+    return "No whitelist file found at ~/.connectonion/trusted.txt"
+
+
+def test_capability(agent_id: str, test: str, expected: str) -> str:
+    """
+    Test an agent's capability with a specific test.
+    
+    Args:
+        agent_id: Identifier of the agent to test
+        test: The test to perform
+        expected: The expected result
+        
+    Returns:
+        Test description for the trust agent to evaluate
+    """
+    return f"Testing {agent_id} with: {test}, expecting: {expected}"
+
+
+def verify_agent(agent_id: str, agent_info: str = "") -> str:
+    """
+    General verification of an agent.
+    
+    Args:
+        agent_id: Identifier of the agent
+        agent_info: Additional information about the agent
+        
+    Returns:
+        Verification context for the trust agent
+    """
+    return f"Verifying agent: {agent_id}. Info: {agent_info}"
+
+
+def get_trust_verification_tools() -> List[Callable]:
+    """
+    Get the list of trust verification tools.
+    
+    Returns:
+        List of trust verification functions
+    """
+    return [
+        check_whitelist,
+        test_capability,
+        verify_agent
+    ]

connectonion/tui/__init__.py

@@ -0,0 +1,57 @@
+"""
+Purpose: Terminal UI components for interactive agent interfaces with powerline-style rendering
+LLM-Note:
+  Dependencies: imports from [input, dropdown, providers, keys, fuzzy, status_bar, divider, pick, footer] | imported by [useful_tools/__init__.py, useful_tools/terminal.py] | requires rich library
+  Data flow: agent/CLI imports TUI components → components render to terminal via Rich → user interacts via keyboard → components return selected values
+  State/Effects: manages terminal state during interaction | raw mode for keyboard input | restores terminal on exit
+  Integration: exposes Input (text with autocomplete), Dropdown, FileProvider/StaticProvider (autocomplete sources), StatusBar/SimpleStatusBar/ProgressSegment, Divider, pick (single-select), Footer | keyboard handling via getch/read_key | fuzzy matching via fuzzy_match/highlight_match
+  Performance: renders to terminal in real-time | fuzzy matching is O(n*m) | file provider reads filesystem
+  Errors: KeyboardInterrupt handled for clean exit | terminal restoration on exception
+
+Powerline-style terminal components inspired by powerlevel10k.
+
+Usage:
+    from connectonion.tui import Input, FileProvider, StatusBar, Divider
+
+    # Status bar with model/context/git info
+    status = StatusBar([
+        ("🤖", "co/gemini-2.5-pro", "magenta"),
+        ("📊", "50%", "green"),
+        ("", "main", "blue"),
+    ])
+    console.print(status.render())
+
+    # Minimal input with @ file autocomplete
+    text = Input(triggers={"@": FileProvider()}).run()
+
+    # Divider line
+    console.print(Divider().render())
+"""
+
+from .input import Input
+from .dropdown import Dropdown, DropdownItem
+from .providers import FileProvider, StaticProvider
+from .keys import getch, read_key
+from .fuzzy import fuzzy_match, highlight_match
+from .status_bar import StatusBar, SimpleStatusBar, ProgressSegment
+from .divider import Divider
+from .pick import pick
+from .footer import Footer
+
+__all__ = [
+    "Input",
+    "Dropdown",
+    "DropdownItem",
+    "FileProvider",
+    "StaticProvider",
+    "getch",
+    "read_key",
+    "fuzzy_match",
+    "highlight_match",
+    "StatusBar",
+    "SimpleStatusBar",
+    "ProgressSegment",
+    "Divider",
+    "pick",
+    "Footer",
+]

connectonion/tui/divider.py

@@ -0,0 +1,39 @@
+"""Divider - Simple horizontal line separator.
+
+A minimal line to separate sections in terminal UI.
+"""
+
+from rich.text import Text
+
+
+class Divider:
+    """Simple horizontal divider line.
+
+    Usage:
+        from connectonion.tui import Divider
+
+        divider = Divider()
+        console.print(divider.render())
+
+        # Custom width
+        divider = Divider(width=40)
+        console.print(divider.render())
+
+    Output:
+        ────────────────────────────────────
+    """
+
+    def __init__(self, width: int = 40, char: str = "─", style: str = "dim"):
+        """
+        Args:
+            width: Width of the divider line
+            char: Character to use for the line
+            style: Rich style for the line
+        """
+        self.width = width
+        self.char = char
+        self.style = style
+
+    def render(self) -> Text:
+        """Render the divider line."""
+        return Text(self.char * self.width, style=self.style)

connectonion/tui/dropdown.py

@@ -0,0 +1,251 @@
+"""Dropdown - reusable selection list component.
+
+Modern zsh-style dropdown with icons and highlighting.
+"""
+
+from dataclasses import dataclass, field
+from typing import Any
+
+from rich.text import Text
+from rich.table import Table
+from rich.console import Group
+
+from .fuzzy import highlight_match
+
+
+@dataclass
+class DropdownItem:
+    """Structured item for dropdown display.
+
+    Supports rich metadata for different display styles.
+
+    Usage:
+        # Simple item
+        item = DropdownItem(display="/today", value="/today")
+
+        # With description (shows on second line or right side)
+        item = DropdownItem(
+            display="/today",
+            value="/today",
+            description="Daily email briefing",
+            icon="📅"
+        )
+
+        # Contact style
+        item = DropdownItem(
+            display="Davis Baer",
+            value="davis@oneupapp.io",
+            description="davis@oneupapp.io",
+            subtitle="OneUp · founder",
+            icon="👤"
+        )
+    """
+    display: str                    # Main text to show
+    value: Any                      # Value to return when selected
+    score: int = 0                  # Match score for sorting
+    positions: list[int] = field(default_factory=list)  # Matched char positions
+    description: str = ""           # Secondary text (right side or second line)
+    subtitle: str = ""              # Third line or additional context
+    icon: str = ""                  # Left icon (emoji or nerd font)
+    style: str = ""                 # Rich style for the display text
+
+    @classmethod
+    def from_tuple(cls, item: tuple) -> "DropdownItem":
+        """Convert old tuple format to DropdownItem for backward compatibility.
+
+        Supports:
+            (display, value, score, positions)
+            (display, value, score, positions, metadata_dict)
+        """
+        if isinstance(item, DropdownItem):
+            return item
+
+        display, value, score, positions = item[:4]
+        metadata = item[4] if len(item) > 4 else {}
+
+        return cls(
+            display=display,
+            value=value,
+            score=score,
+            positions=positions or [],
+            description=metadata.get("description", ""),
+            subtitle=metadata.get("subtitle", ""),
+            icon=metadata.get("icon", ""),
+            style=metadata.get("style", ""),
+        )
+
+
+# File type icons (requires Nerd Font for best results, fallback to unicode)
+ICONS = {
+    "folder": "📁",
+    "python": "🐍",
+    "javascript": "📜",
+    "typescript": "📘",
+    "json": "📋",
+    "markdown": "📝",
+    "yaml": "⚙️",
+    "default": "📄",
+}
+
+
+def get_file_icon(name: str) -> str:
+    """Get icon for file based on extension."""
+    if name.endswith('/'):
+        return ICONS["folder"]
+    ext = name.rsplit('.', 1)[-1].lower() if '.' in name else ""
+    if ext == "py":
+        return ICONS["python"]
+    elif ext in ("js", "jsx"):
+        return ICONS["javascript"]
+    elif ext in ("ts", "tsx"):
+        return ICONS["typescript"]
+    elif ext == "json":
+        return ICONS["json"]
+    elif ext in ("md", "mdx"):
+        return ICONS["markdown"]
+    elif ext in ("yml", "yaml"):
+        return ICONS["yaml"]
+    return ICONS["default"]
+
+
+class Dropdown:
+    """Dropdown selection list with keyboard navigation.
+
+    Modern zsh-style with icons and fuzzy match highlighting.
+    Supports DropdownItem for rich metadata display.
+
+    Usage:
+        dropdown = Dropdown(max_visible=8)
+
+        # Old tuple format (backward compatible)
+        dropdown.set_items([
+            ("agent.py", "agent.py", 10, [0,1,2]),
+            ("main.py", "main.py", 5, [0,1]),
+        ])
+
+        # New DropdownItem format
+        dropdown.set_items([
+            DropdownItem("/today", "/today", description="Daily briefing", icon="📅"),
+            DropdownItem("/inbox", "/inbox", description="Show emails", icon="📥"),
+        ])
+
+        dropdown.down()  # Move selection
+        selected = dropdown.selected_value  # Get current selection
+    """
+
+    def __init__(self, max_visible: int = 8, show_icons: bool = True):
+        self.max_visible = max_visible
+        self.show_icons = show_icons
+        self.items: list[DropdownItem] = []
+        self.selected_index = 0
+
+    def set_items(self, items: list):
+        """Set items. Accepts DropdownItem or old tuple format."""
+        converted = []
+        for item in items[:self.max_visible]:
+            if isinstance(item, DropdownItem):
+                converted.append(item)
+            else:
+                converted.append(DropdownItem.from_tuple(item))
+        self.items = converted
+        self.selected_index = 0
+
+    def clear(self):
+        """Clear all items."""
+        self.items = []
+        self.selected_index = 0
+
+    @property
+    def is_empty(self) -> bool:
+        return len(self.items) == 0
+
+    @property
+    def selected_value(self):
+        """Get currently selected value."""
+        if self.items and self.selected_index < len(self.items):
+            return self.items[self.selected_index].value
+        return None
+
+    @property
+    def selected_display(self) -> str:
+        """Get currently selected display text."""
+        if self.items and self.selected_index < len(self.items):
+            return self.items[self.selected_index].display
+        return ""
+
+    def up(self):
+        """Move selection up."""
+        if self.items:
+            self.selected_index = (self.selected_index - 1) % len(self.items)
+
+    def down(self):
+        """Move selection down."""
+        if self.items:
+            self.selected_index = (self.selected_index + 1) % len(self.items)
+
+    def _get_icon(self, item: DropdownItem) -> str:
+        """Get icon for item - use item.icon if set, otherwise infer from filename."""
+        if item.icon:
+            return item.icon
+        if self.show_icons:
+            return get_file_icon(item.display)
+        return ""
+
+    def render(self) -> Table:
+        """Render dropdown as Rich Table.
+
+        Supports multiple display modes based on DropdownItem fields:
+        - Simple: just display text with icon
+        - With description: display + description on right
+        - With subtitle: two-line display
+
+        Selected item has light background for visibility on both light/dark terminals.
+        """
+        table = Table(show_header=False, box=None, padding=(0, 0), show_edge=False)
+
+        for i, item in enumerate(self.items):
+            is_selected = i == self.selected_index
+            row = Text()
+
+            # Selection indicator
+            if is_selected:
+                row.append("  ❯ ", style="bold green")
+            else:
+                row.append("    ", style="dim")
+
+            # Icon
+            icon = self._get_icon(item)
+            if icon:
+                if is_selected:
+                    row.append(f"{icon} ", style="bold")
+                else:
+                    row.append(f"{icon} ", style="dim")
+
+            # Main display text with highlighting
+            display_style = item.style if item.style else ""
+            highlighted = highlight_match(item.display, item.positions)
+            if display_style:
+                highlighted.stylize(display_style)
+            row.append_text(highlighted)
+
+            # Description (right side, dimmed)
+            if item.description:
+                row.append("  ", style="dim")
+                row.append(item.description, style="dim italic")
+
+            # Add background to selected row
+            if is_selected:
+                row.stylize("on bright_black")
+
+            table.add_row(row)
+
+            # Subtitle as second line (only for selected or all items with subtitle)
+            if item.subtitle and is_selected:
+                subtitle_row = Text()
+                subtitle_row.append("        ", style="dim")  # Indent to align with text
+                subtitle_row.append(item.subtitle, style="dim")
+                if is_selected:
+                    subtitle_row.stylize("on bright_black")
+                table.add_row(subtitle_row)
+
+        return table