mindroom 0.0.0__py3-none-any.whl → 0.1.1__py3-none-any.whl

mindroom/config.py

@@ -0,0 +1,343 @@
+"""Pydantic models for configuration."""
+
+from __future__ import annotations
+
+from functools import cached_property
+from pathlib import Path
+from typing import TYPE_CHECKING, Any
+
+import yaml
+from pydantic import BaseModel, Field
+
+from .constants import DEFAULT_AGENTS_CONFIG, MATRIX_HOMESERVER, ROUTER_AGENT_NAME
+from .logging_config import get_logger
+
+if TYPE_CHECKING:
+    from .matrix.identity import MatrixID
+
+logger = get_logger(__name__)
+
+
+class AgentConfig(BaseModel):
+    """Configuration for a single agent."""
+
+    display_name: str = Field(description="Human-readable name for the agent")
+    role: str = Field(default="", description="Description of the agent's purpose")
+    tools: list[str] = Field(default_factory=list, description="List of tool names")
+    instructions: list[str] = Field(default_factory=list, description="Agent instructions")
+    rooms: list[str] = Field(default_factory=list, description="List of room IDs or names to auto-join")
+    num_history_runs: int | None = Field(default=None, description="Number of history runs to include")
+    markdown: bool | None = Field(default=None, description="Whether to use markdown formatting")
+    add_history_to_messages: bool | None = Field(default=None, description="Whether to add history to messages")
+    model: str = Field(default="default", description="Model name")
+
+
+class DefaultsConfig(BaseModel):
+    """Default configuration values for agents."""
+
+    num_history_runs: int = Field(default=5, description="Default number of history runs")
+    markdown: bool = Field(default=True, description="Default markdown setting")
+    add_history_to_messages: bool = Field(default=True, description="Default history setting")
+    show_stop_button: bool = Field(default=False, description="Whether to automatically show stop button on messages")
+
+
+class EmbedderConfig(BaseModel):
+    """Configuration for memory embedder."""
+
+    model: str = Field(default="text-embedding-3-small", description="Model name for embeddings")
+    api_key: str | None = Field(default=None, description="API key (usually from environment variable)")
+    host: str | None = Field(default=None, description="Host URL for self-hosted models like Ollama")
+
+
+class MemoryEmbedderConfig(BaseModel):
+    """Memory embedder configuration."""
+
+    provider: str = Field(default="openai", description="Embedder provider (openai, huggingface, etc)")
+    config: EmbedderConfig = Field(default_factory=EmbedderConfig, description="Provider-specific config")
+
+
+class MemoryLLMConfig(BaseModel):
+    """Memory LLM configuration."""
+
+    provider: str = Field(default="ollama", description="LLM provider (ollama, openai, anthropic)")
+    config: dict[str, Any] = Field(default_factory=dict, description="Provider-specific LLM config")
+
+
+class MemoryConfig(BaseModel):
+    """Memory system configuration."""
+
+    embedder: MemoryEmbedderConfig = Field(
+        default_factory=MemoryEmbedderConfig,
+        description="Embedder configuration for memory",
+    )
+    llm: MemoryLLMConfig | None = Field(default=None, description="LLM configuration for memory")
+
+
+class ModelConfig(BaseModel):
+    """Configuration for an AI model."""
+
+    provider: str = Field(description="Model provider (openai, anthropic, ollama, etc)")
+    id: str = Field(description="Model ID specific to the provider")
+    host: str | None = Field(default=None, description="Optional host URL (e.g., for Ollama)")
+    api_key: str | None = Field(default=None, description="Optional API key (usually from env vars)")
+    extra_kwargs: dict[str, Any] | None = Field(
+        default=None,
+        description="Additional provider-specific parameters passed directly to the model",
+    )
+
+
+class RouterConfig(BaseModel):
+    """Configuration for the router system."""
+
+    model: str = Field(default="default", description="Model to use for routing decisions")
+
+
+class TeamConfig(BaseModel):
+    """Configuration for a team of agents."""
+
+    display_name: str = Field(description="Human-readable name for the team")
+    role: str = Field(description="Description of the team's purpose")
+    agents: list[str] = Field(description="List of agent names that compose this team")
+    rooms: list[str] = Field(default_factory=list, description="List of room IDs or names to auto-join")
+    model: str | None = Field(default="default", description="Default model for this team (optional)")
+    mode: str = Field(default="coordinate", description="Team collaboration mode: coordinate or collaborate")
+
+
+class VoiceSTTConfig(BaseModel):
+    """Configuration for voice speech-to-text."""
+
+    provider: str = Field(default="openai", description="STT provider (openai or compatible)")
+    model: str = Field(default="whisper-1", description="STT model name")
+    api_key: str | None = Field(default=None, description="API key for STT service")
+    host: str | None = Field(default=None, description="Host URL for self-hosted STT")
+
+
+class VoiceLLMConfig(BaseModel):
+    """Configuration for voice command intelligence."""
+
+    model: str = Field(default="default", description="Model for command recognition")
+    confidence_threshold: float = Field(default=0.7, description="Confidence threshold for commands")
+
+
+class VoiceConfig(BaseModel):
+    """Configuration for voice message handling."""
+
+    enabled: bool = Field(default=False, description="Enable voice message processing")
+    stt: VoiceSTTConfig = Field(default_factory=VoiceSTTConfig, description="STT configuration")
+    intelligence: VoiceLLMConfig = Field(
+        default_factory=VoiceLLMConfig,
+        description="Command intelligence configuration",
+    )
+
+
+class AuthorizationConfig(BaseModel):
+    """Authorization configuration with fine-grained permissions."""
+
+    global_users: list[str] = Field(
+        default_factory=list,
+        description="Users with access to all rooms (e.g., '@user:example.com')",
+    )
+    room_permissions: dict[str, list[str]] = Field(
+        default_factory=dict,
+        description="Room-specific user permissions. Keys are room IDs, values are lists of authorized user IDs",
+    )
+    default_room_access: bool = Field(
+        default=False,
+        description="Default permission for rooms not explicitly configured",
+    )
+
+
+class Config(BaseModel):
+    """Complete configuration from YAML."""
+
+    agents: dict[str, AgentConfig] = Field(default_factory=dict, description="Agent configurations")
+    teams: dict[str, TeamConfig] = Field(default_factory=dict, description="Team configurations")
+    room_models: dict[str, str] = Field(default_factory=dict, description="Room-specific model overrides")
+    defaults: DefaultsConfig = Field(default_factory=DefaultsConfig, description="Default values")
+    memory: MemoryConfig = Field(default_factory=MemoryConfig, description="Memory configuration")
+    models: dict[str, ModelConfig] = Field(default_factory=dict, description="Model configurations")
+    router: RouterConfig = Field(default_factory=RouterConfig, description="Router configuration")
+    voice: VoiceConfig = Field(default_factory=VoiceConfig, description="Voice configuration")
+    timezone: str = Field(
+        default="UTC",
+        description="Timezone for displaying scheduled tasks (e.g., 'America/New_York')",
+    )
+    authorization: AuthorizationConfig = Field(
+        default_factory=AuthorizationConfig,
+        description="Authorization configuration with fine-grained permissions",
+    )
+
+    @cached_property
+    def domain(self) -> str:
+        """Extract the domain from the MATRIX_HOMESERVER."""
+        from .matrix.identity import extract_server_name_from_homeserver  # noqa: PLC0415
+
+        return extract_server_name_from_homeserver(MATRIX_HOMESERVER)
+
+    @cached_property
+    def ids(self) -> dict[str, MatrixID]:
+        """Get MatrixID objects for all agents and teams.
+
+        Returns:
+            Dictionary mapping agent/team names to their MatrixID objects.
+
+        """
+        from .matrix.identity import MatrixID  # noqa: PLC0415
+
+        mapping: dict[str, MatrixID] = {}
+
+        # Add all agents
+        for agent_name in self.agents:
+            mapping[agent_name] = MatrixID.from_agent(agent_name, self.domain)
+
+        # Add router agent separately (it's not in config.agents)
+        mapping[ROUTER_AGENT_NAME] = MatrixID.from_agent(ROUTER_AGENT_NAME, self.domain)
+
+        # Add all teams
+        for team_name in self.teams:
+            mapping[team_name] = MatrixID.from_agent(team_name, self.domain)
+        return mapping
+
+    @classmethod
+    def from_yaml(cls, config_path: Path | None = None) -> Config:
+        """Create a Config instance from YAML data."""
+        path = config_path or DEFAULT_AGENTS_CONFIG
+
+        if not path.exists():
+            msg = f"Agent configuration file not found: {path}"
+            raise FileNotFoundError(msg)
+
+        with path.open() as f:
+            data = yaml.safe_load(f)
+
+        # Handle None values for optional dictionaries
+        if data.get("teams") is None:
+            data["teams"] = {}
+        if data.get("room_models") is None:
+            data["room_models"] = {}
+
+        config = cls(**data)
+        logger.info(f"Loaded agent configuration from {path}")
+        logger.info(f"Found {len(config.agents)} agent configurations")
+        return config
+
+    def get_agent(self, agent_name: str) -> AgentConfig:
+        """Get an agent configuration by name.
+
+        Args:
+            agent_name: Name of the agent
+
+        Returns:
+            Agent configuration
+
+        Raises:
+            ValueError: If agent not found
+
+        """
+        if agent_name not in self.agents:
+            available = ", ".join(sorted(self.agents.keys()))
+            msg = f"Unknown agent: {agent_name}. Available agents: {available}"
+            raise ValueError(msg)
+        return self.agents[agent_name]
+
+    def get_all_configured_rooms(self) -> set[str]:
+        """Extract all room aliases configured for agents and teams.
+
+        Returns:
+            Set of all unique room aliases from agent and team configurations
+
+        """
+        all_room_aliases = set()
+        for agent_config in self.agents.values():
+            all_room_aliases.update(agent_config.rooms)
+        for team_config in self.teams.values():
+            all_room_aliases.update(team_config.rooms)
+        return all_room_aliases
+
+    def get_entity_model_name(self, entity_name: str) -> str:
+        """Get the model name for an agent, team, or router.
+
+        Args:
+            entity_name: Name of the entity (agent, team, or router)
+
+        Returns:
+            Model name (e.g., "default", "gpt-4", etc.)
+
+        Raises:
+            ValueError: If entity_name is not found in configuration
+
+        """
+        # Router uses router model
+        if entity_name == ROUTER_AGENT_NAME:
+            return self.router.model
+        # Teams use their configured model (required to have one)
+        if entity_name in self.teams:
+            model = self.teams[entity_name].model
+            if model is None:
+                msg = f"Team {entity_name} has no model configured"
+                raise ValueError(msg)
+            return model
+        # Regular agents use their configured model
+        if entity_name in self.agents:
+            return self.agents[entity_name].model
+
+        # Entity not found in any category
+        available = sorted(set(self.agents.keys()) | set(self.teams.keys()) | {ROUTER_AGENT_NAME})
+        msg = f"Unknown entity: {entity_name}. Available entities: {', '.join(available)}"
+        raise ValueError(msg)
+
+    def get_configured_bots_for_room(self, room_id: str) -> set[str]:
+        """Get the set of bot usernames that should be in a specific room.
+
+        Args:
+            room_id: The Matrix room ID
+
+        Returns:
+            Set of bot usernames (without domain) that should be in this room
+
+        """
+        from .matrix.rooms import resolve_room_aliases  # noqa: PLC0415
+
+        configured_bots = set()
+
+        # Check which agents should be in this room
+        for agent_name, agent_config in self.agents.items():
+            resolved_rooms = set(resolve_room_aliases(agent_config.rooms))
+            if room_id in resolved_rooms:
+                configured_bots.add(f"mindroom_{agent_name}")
+
+        # Check which teams should be in this room
+        for team_name, team_config in self.teams.items():
+            resolved_rooms = set(resolve_room_aliases(team_config.rooms))
+            if room_id in resolved_rooms:
+                configured_bots.add(f"mindroom_{team_name}")
+
+        # Router should be in any room that has any configured agents/teams
+        if configured_bots:  # If any bots are configured for this room
+            configured_bots.add(f"mindroom_{ROUTER_AGENT_NAME}")
+
+        return configured_bots
+
+    def save_to_yaml(self, config_path: Path | None = None) -> None:
+        """Save the config to a YAML file, excluding None values.
+
+        Args:
+            config_path: Path to save the config to. If None, uses DEFAULT_AGENTS_CONFIG.
+
+        """
+        path = config_path or DEFAULT_AGENTS_CONFIG
+        config_dict = self.model_dump(exclude_none=True)
+        path_obj = Path(path)
+        path_obj.parent.mkdir(parents=True, exist_ok=True)
+        tmp_path = path_obj.with_suffix(path_obj.suffix + ".tmp")
+        with tmp_path.open("w", encoding="utf-8") as f:
+            yaml.dump(
+                config_dict,
+                f,
+                default_flow_style=False,
+                sort_keys=True,
+                allow_unicode=True,  # Preserve Unicode characters like ë
+                width=120,  # Wider lines to reduce wrapping
+            )
+        tmp_path.replace(path_obj)
+        logger.info(f"Saved configuration to {path}")

mindroom/config_commands.py

@@ -0,0 +1,324 @@
+"""Configuration command handling for user-driven config changes."""
+
+from __future__ import annotations
+
+import shlex
+from pathlib import Path  # noqa: TC003
+from typing import Any
+
+import yaml
+from pydantic import ValidationError
+
+from .config import Config
+from .constants import DEFAULT_AGENTS_CONFIG
+from .logging_config import get_logger
+
+logger = get_logger(__name__)
+
+
+def parse_config_args(args_text: str) -> tuple[str, list[str]]:
+    """Parse config command arguments.
+
+    Args:
+        args_text: Raw argument text from command
+
+    Returns:
+        Tuple of (operation, arguments)
+
+    """
+    if not args_text:
+        return "show", []
+
+    # Use shlex to handle quoted strings properly
+    try:
+        parts = shlex.split(args_text)
+    except ValueError as e:
+        # Handle parsing errors (e.g., unmatched quotes)
+        # Return a special operation that will trigger an error message
+        return "parse_error", [str(e)]
+
+    if not parts:
+        return "show", []
+
+    operation = parts[0].lower()
+    args = parts[1:] if len(parts) > 1 else []
+    return operation, args
+
+
+def get_nested_value(data: Any, path: str) -> Any:  # noqa: ANN401
+    """Get a value from nested dict using dot notation.
+
+    Args:
+        data: The dictionary to search
+        path: Dot-separated path (e.g., "agents.analyst.display_name")
+
+    Returns:
+        The value at the path
+
+    Raises:
+        KeyError: If path doesn't exist
+
+    """
+    keys = path.split(".")
+    current = data
+
+    for key in keys:
+        # Handle array indexing
+        if key.isdigit():  # noqa: SIM108
+            current = current[int(key)]
+        else:
+            current = current[key]
+
+    return current
+
+
+def set_nested_value(data: Any, path: str, value: Any) -> None:  # noqa: ANN401
+    """Set a value in nested dict using dot notation.
+
+    Args:
+        data: The dictionary to modify
+        path: Dot-separated path (e.g., "agents.analyst.display_name")
+        value: Value to set
+
+    Raises:
+        KeyError: If parent path doesn't exist
+
+    """
+    keys = path.split(".")
+    current = data
+
+    # Navigate to the parent of the target
+    for key in keys[:-1]:
+        if key.isdigit():
+            current = current[int(key)]
+        elif key not in current:
+            # Auto-create missing intermediate dicts
+            current[key] = {}
+            current = current[key]
+        else:
+            current = current[key]
+
+    # Set the final value
+    final_key = keys[-1]
+    if final_key.isdigit():
+        current[int(final_key)] = value
+    else:
+        current[final_key] = value
+
+
+def parse_value(value_str: str) -> Any:  # noqa: ANN401
+    """Parse a string value into appropriate Python type.
+
+    Args:
+        value_str: String representation of value
+
+    Returns:
+        Parsed value (str, int, float, bool, list, or dict)
+
+    """
+    # Try to parse as YAML first (handles unquoted strings in arrays/dicts)
+    # YAML is a superset of JSON, so this handles both formats
+    # Examples that work:
+    #   [item1, item2]          -> ['item1', 'item2']
+    #   ["item1", "item2"]      -> ['item1', 'item2']
+    #   {key: value}            -> {'key': 'value'}
+    #   {"key": "value"}        -> {'key': 'value'}
+    try:
+        return yaml.safe_load(value_str)
+    except yaml.YAMLError:
+        pass
+
+    # If YAML parsing fails, return as string
+    # This handles cases where the string itself contains special YAML characters
+    return value_str
+
+
+def format_value(value: Any) -> str:  # noqa: ANN401
+    """Format a value for display as YAML.
+
+    Args:
+        value: Value to format
+
+    Returns:
+        YAML formatted string representation
+
+    """
+    # Use yaml.dump for consistent formatting
+    yaml_str = yaml.dump(value, default_flow_style=False, sort_keys=False, allow_unicode=True)
+    # Remove trailing newline and document end marker that yaml.dump adds
+    yaml_str = yaml_str.rstrip()
+    if yaml_str.endswith("..."):
+        yaml_str = yaml_str[:-3].rstrip()
+    return yaml_str
+
+
+async def handle_config_command(args_text: str, config_path: Path | None = None) -> tuple[str, dict[str, Any] | None]:  # noqa: C901, PLR0911, PLR0912
+    """Handle config command execution.
+
+    Args:
+        args_text: The command arguments
+        config_path: Optional path to config file
+
+    Returns:
+        Tuple of (response message, config change dict or None)
+        The config change dict contains info needed for confirmation
+
+    """
+    operation, args = parse_config_args(args_text)
+    path = config_path or DEFAULT_AGENTS_CONFIG
+
+    # Load current config
+    config = Config.from_yaml(path)
+    config_dict = config.model_dump(exclude_none=True)
+
+    if operation == "show":
+        # Show entire config
+        yaml_str = yaml.dump(config_dict, default_flow_style=False, sort_keys=False, allow_unicode=True)
+        return f"**Current Configuration:**\n```yaml\n{yaml_str}```", None
+
+    if operation == "get":
+        if not args:
+            return (
+                "❌ Please specify a configuration path to get\nExample: `!config get agents.analyst.display_name`",
+                None,
+            )
+
+        config_path_str = args[0]
+        try:
+            value = get_nested_value(config_dict, config_path_str)
+        except (KeyError, IndexError) as e:
+            return f"❌ Configuration path not found: `{config_path_str}`\nError: {e}", None
+        else:
+            formatted = format_value(value)
+            return f"**Configuration value for `{config_path_str}`:**\n```yaml\n{formatted}\n```", None
+
+    elif operation == "set":
+        if len(args) < 2:
+            return (
+                '❌ Please specify a path and value\nExample: `!config set agents.analyst.display_name "New Name"`',
+                None,
+            )
+
+        config_path_str = args[0]
+        # Join remaining args as the value (handles unquoted strings with spaces)
+        value_str = " ".join(args[1:])
+
+        # Parse the value - YAML parsing handles both quoted and unquoted formats
+        value = parse_value(value_str)
+
+        # Get the current value for comparison
+        try:
+            old_value = get_nested_value(config_dict, config_path_str)
+        except (KeyError, IndexError):
+            old_value = None  # Path doesn't exist yet
+
+        # Create a copy to test the change
+        test_config_dict = config_dict.copy()
+
+        try:
+            # Verify the path exists or can be created
+            set_nested_value(test_config_dict, config_path_str, value)
+
+            # Validate the modified config
+            Config(**test_config_dict)  # This will raise ValidationError if invalid
+        except (KeyError, IndexError) as e:
+            return f"❌ Configuration path error: `{config_path_str}`\nError: {e}", None
+        except ValidationError as e:
+            # Validation failed - explain why
+            errors = []
+            for error in e.errors():
+                location = " → ".join(str(loc) for loc in error["loc"])
+                errors.append(f"• {location}: {error['msg']}")
+            error_msg = "\n".join(errors)
+            return f"❌ Invalid configuration:\n{error_msg}\n\nChanges were NOT applied.", None
+        else:
+            # Format the preview message
+            formatted_old = format_value(old_value) if old_value is not None else "Not set"
+            formatted_new = format_value(value)
+
+            preview_msg = (
+                f"**Configuration Change Preview**\n\n"
+                f"📝 **Path:** `{config_path_str}`\n\n"
+                f"**Current value:**\n```yaml\n{formatted_old}\n```\n"
+                f"**New value:**\n```yaml\n{formatted_new}\n```\n\n"
+                f"React with ✅ to confirm or ❌ to cancel this change."
+            )
+
+            # Return the preview and the change info for confirmation
+            change_info = {
+                "config_path": config_path_str,
+                "old_value": old_value,
+                "new_value": value,
+                "path": str(path),
+            }
+
+            return preview_msg, change_info
+
+    elif operation == "parse_error":
+        # Handle parsing errors (e.g., unmatched quotes)
+        error_msg = args[0] if args else "Unknown parsing error"
+        return (
+            f"❌ **Command parsing error:**\n{error_msg}\n\n"
+            "**Common issues:**\n"
+            "• Unmatched quotes: Make sure quotes are properly paired\n"
+            '• For JSON arrays/objects, use matching quotes: `["item1", "item2"]`\n'
+            "• Or use single quotes consistently: `['item1', 'item2']`\n\n"
+            "**Example:**\n"
+            '`!config set agents.analyst.tools ["tool1", "tool2"]`'
+        ), None
+
+    else:
+        available_ops = ["show", "get", "set"]
+        return (
+            f"❌ Unknown operation: '{operation}'\n"
+            f"Available operations: {', '.join(available_ops)}\n\n"
+            "Try `!help config` for usage examples."
+        ), None
+
+
+async def apply_config_change(
+    config_path_str: str,
+    new_value: Any,  # noqa: ANN401
+    config_file_path: Path | None = None,
+) -> str:
+    """Apply a confirmed configuration change.
+
+    Args:
+        config_path_str: The configuration path (e.g., "agents.analyst.role")
+        new_value: The new value to set
+        config_file_path: Optional path to config file
+
+    Returns:
+        Success or error message
+
+    """
+    path = config_file_path or DEFAULT_AGENTS_CONFIG
+
+    try:
+        # Load the current configuration
+        config = Config.from_yaml(path)
+        config_dict = config.model_dump()
+
+        # Apply the specific change
+        set_nested_value(config_dict, config_path_str, new_value)
+
+        # Validate the modified config
+        try:
+            new_config = Config(**config_dict)
+        except ValidationError as ve:
+            errors = ["❌ Configuration validation failed:"]
+            for error in ve.errors():
+                location = " → ".join(str(loc) for loc in error["loc"])
+                errors.append(f"• {location}: {error['msg']}")
+            error_msg = "\n".join(errors)
+            return f"{error_msg}\n\nChanges were NOT applied."
+
+        # Save to file
+        new_config.save_to_yaml(path)
+        return (  # noqa: TRY300
+            f"✅ **Configuration updated successfully!**\n\n"
+            f"Changes saved to {path} and will affect new agent interactions."
+        )
+    except Exception as e:
+        logger.exception("Failed to apply config change")
+        return f"❌ Failed to apply configuration change: {e}"