code-muse 0.0.1__py3-none-any.whl

code_muse/config_model.py

@@ -0,0 +1,357 @@
+"""Config: model settings."""
+
+import configparser
+
+import code_muse.config as _config
+
+
+def get_summarization_model_name() -> str:
+    """Return the model used for compaction/summarization.
+
+    Reads the ``summarization_model`` config key. If unset (or empty),
+    falls back to :func:`get_global_model_name`, preserving legacy behavior
+    for users who haven't explicitly configured a separate summarizer.
+
+    Rationale: summarization is a different workload than main-agent chat —
+    it's one-shot, large-context, and best served by a cheap-and-fast or
+    long-context specialist model. Decoupling it from the global model lets
+    users pick the right tool without changing their main agent.
+    """
+    value = _config.get_value("summarization_model")
+    if value:
+        return value
+    return _config.get_global_model_name()
+
+
+def set_summarization_model_name(model: str) -> None:
+    """Persist the summarization model in the config file.
+
+    Pass an empty string to clear the setting and fall back to the global
+    model on subsequent calls to :func:`get_summarization_model_name`.
+    """
+    _config.set_config_value("summarization_model", model or "")
+
+
+def get_muse_token():
+    """Returns the muse_token from config, or None if not set."""
+    return _config.get_value("muse_token")
+
+
+def set_muse_token(token: str):
+    """Sets the muse_token in the persistent config file."""
+    _config.set_config_value("muse_token", token)
+
+
+def get_openai_reasoning_effort() -> str:
+    """Return the configured OpenAI reasoning effort (minimal, low, medium, high, xhigh)."""
+    allowed_values = {"minimal", "low", "medium", "high", "xhigh"}
+    configured = (
+        (_config.get_value("openai_reasoning_effort") or "medium").strip().lower()
+    )
+    if configured not in allowed_values:
+        return "medium"
+    return configured
+
+
+def set_openai_reasoning_effort(value: str) -> None:
+    """Persist the OpenAI reasoning effort ensuring it remains within allowed values."""
+    allowed_values = {"minimal", "low", "medium", "high", "xhigh"}
+    normalized = (value or "").strip().lower()
+    if normalized not in allowed_values:
+        raise ValueError(
+            f"Invalid reasoning effort '{value}'. Allowed: {', '.join(sorted(allowed_values))}"
+        )
+    _config.set_config_value("openai_reasoning_effort", normalized)
+
+
+def get_openai_reasoning_summary() -> str:
+    """Return the configured OpenAI reasoning summary mode.
+
+    Supported values:
+    - auto: let the provider decide the best summary style
+    - concise: shorter reasoning summaries
+    - detailed: fuller reasoning summaries
+    """
+    allowed_values = {"auto", "concise", "detailed"}
+    configured = (
+        (_config.get_value("openai_reasoning_summary") or "detailed").strip().lower()
+    )
+    if configured not in allowed_values:
+        return "auto"
+    return configured
+
+
+def set_openai_reasoning_summary(value: str) -> None:
+    """Persist the OpenAI reasoning summary mode ensuring it remains valid."""
+    allowed_values = {"auto", "concise", "detailed"}
+    normalized = (value or "").strip().lower()
+    if normalized not in allowed_values:
+        raise ValueError(
+            f"Invalid reasoning summary '{value}'. Allowed: {', '.join(sorted(allowed_values))}"
+        )
+    _config.set_config_value("openai_reasoning_summary", normalized)
+
+
+def get_openai_verbosity() -> str:
+    """Return the configured OpenAI verbosity (low, medium, high).
+
+    Controls how concise vs. verbose the model's responses are:
+    - low: more concise responses
+    - medium: balanced (default)
+    - high: more verbose responses
+    """
+    allowed_values = {"low", "medium", "high"}
+    configured = (_config.get_value("openai_verbosity") or "medium").strip().lower()
+    if configured not in allowed_values:
+        return "medium"
+    return configured
+
+
+def set_openai_verbosity(value: str) -> None:
+    """Persist the OpenAI verbosity ensuring it remains within allowed values."""
+    allowed_values = {"low", "medium", "high"}
+    normalized = (value or "").strip().lower()
+    if normalized not in allowed_values:
+        raise ValueError(
+            f"Invalid verbosity '{value}'. Allowed: {', '.join(sorted(allowed_values))}"
+        )
+    _config.set_config_value("openai_verbosity", normalized)
+
+
+def get_temperature() -> float | None:
+    """Return the configured model temperature (0.0 to 2.0).
+
+    Returns:
+        Float between 0.0 and 2.0 if set, None if not configured.
+        This allows each model to use its own default when not overridden.
+    """
+    val = _config.get_value("temperature")
+    if val is None or val.strip() == "":
+        return None
+    try:
+        temp = float(val)
+        # Clamp to valid range (most APIs accept 0-2)
+        return max(0.0, min(2.0, temp))
+    except ValueError, TypeError:
+        return None
+
+
+def set_temperature(value: float | None) -> None:
+    """Set the global model temperature in config.
+
+    Args:
+        value: Temperature between 0.0 and 2.0, or None to clear.
+               Lower values = more deterministic, higher = more creative.
+
+    Note: Consider using set_model_setting() for per-model temperature.
+    """
+    if value is None:
+        _config.set_config_value("temperature", "")
+    else:
+        # Validate and clamp
+        temp = max(0.0, min(2.0, float(value)))
+        _config.set_config_value("temperature", str(temp))
+
+
+def _sanitize_model_name_for_key(model_name: str) -> str:
+    """Sanitize model name for use in config keys.
+
+    Replaces characters that might cause issues in config keys.
+    """
+    # Replace problematic characters with underscores
+    sanitized = model_name.replace(".", "_").replace("-", "_").replace("/", "_")
+    return sanitized.lower()
+
+
+def get_model_setting(
+    model_name: str, setting: str, default: float | None = None
+) -> float | None:
+    """Get a specific setting for a model.
+
+    Args:
+        model_name: The model name (e.g., 'gpt-5', 'wafer.ai-glm-5.1')
+        setting: The setting name (e.g., 'temperature', 'top_p', 'seed')
+        default: Default value if not set
+
+    Returns:
+        The setting value as a float, or default if not set.
+    """
+    sanitized_name = _config._sanitize_model_name_for_key(model_name)
+    key = f"model_settings_{sanitized_name}_{setting}"
+    val = _config.get_value(key)
+
+    if val is None or val.strip() == "":
+        return default
+
+    try:
+        return float(val)
+    except ValueError, TypeError:
+        return default
+
+
+def set_model_setting(model_name: str, setting: str, value: float | None) -> None:
+    """Set a specific setting for a model.
+
+    Args:
+        model_name: The model name (e.g., 'gpt-5', 'wafer.ai-glm-5.1')
+        setting: The setting name (e.g., 'temperature', 'seed')
+        value: The value to set, or None to clear
+    """
+    sanitized_name = _config._sanitize_model_name_for_key(model_name)
+    key = f"model_settings_{sanitized_name}_{setting}"
+
+    if value is None:
+        _config.set_config_value(key, "")
+    elif isinstance(value, float):
+        # Round floats to nearest hundredth to avoid floating point weirdness
+        # (allows 0.05 step increments for temperature/top_p)
+        _config.set_config_value(key, str(round(value, 2)))
+    else:
+        _config.set_config_value(key, str(value))
+
+
+def get_all_model_settings(model_name: str) -> dict:
+    """Get all settings for a specific model.
+
+    Args:
+        model_name: The model name
+
+    Returns:
+        Dictionary of setting_name -> value for all configured settings.
+    """
+
+    sanitized_name = _config._sanitize_model_name_for_key(model_name)
+    prefix = f"model_settings_{sanitized_name}_"
+
+    config = configparser.ConfigParser()
+    config.read(_config.CONFIG_FILE)
+
+    settings = {}
+    if _config.DEFAULT_SECTION in config:
+        for key, val in config[_config.DEFAULT_SECTION].items():
+            if key.startswith(prefix) and val.strip():
+                setting_name = key[len(prefix) :]
+                # Handle different value types
+                val_stripped = val.strip()
+                # Check for boolean values first
+                if val_stripped.lower() in ("true", "false"):
+                    settings[setting_name] = val_stripped.lower() == "true"
+                else:
+                    # Try to parse as number (int first, then float)
+                    try:
+                        # Try int first for cleaner values like budget_tokens
+                        if "." not in val_stripped:
+                            settings[setting_name] = int(val_stripped)
+                        else:
+                            settings[setting_name] = float(val_stripped)
+                    except ValueError, TypeError:
+                        # Keep as string if not a number
+                        settings[setting_name] = val_stripped
+
+    return settings
+
+
+def clear_model_settings(model_name: str) -> None:
+    """Clear all settings for a specific model.
+
+    Args:
+        model_name: The model name
+    """
+
+    sanitized_name = _config._sanitize_model_name_for_key(model_name)
+    prefix = f"model_settings_{sanitized_name}_"
+
+    config = configparser.ConfigParser()
+    config.read(_config.CONFIG_FILE)
+
+    if _config.DEFAULT_SECTION in config:
+        keys_to_remove = [
+            key for key in config[_config.DEFAULT_SECTION] if key.startswith(prefix)
+        ]
+        for key in keys_to_remove:
+            del config[_config.DEFAULT_SECTION][key]
+
+        with open(_config.CONFIG_FILE, "w", encoding="utf-8") as f:
+            config.write(f)
+
+
+def get_effective_model_settings(model_name: str | None = None) -> dict:
+    """Get all effective settings for a model, filtered by what the model supports.
+
+    This is the generalized way to get model settings. It:
+    1. Gets all per-model settings from config
+    2. Falls back to global temperature if not set per-model
+    3. Filters to only include settings the model actually supports
+    4. Converts seed to int (other settings stay as float)
+
+    Args:
+        model_name: The model name. If None, uses the current global model.
+
+    Returns:
+        Dictionary of setting_name -> value for all applicable settings.
+        Ready to be unpacked into ModelSettings.
+    """
+    if model_name is None:
+        model_name = _config.get_global_model_name()
+
+    # Start with all per-model settings
+    settings = _config.get_all_model_settings(model_name)
+
+    # Fall back to global temperature if not set per-model
+    if "temperature" not in settings:
+        global_temp = _config.get_temperature()
+        if global_temp is not None:
+            settings["temperature"] = global_temp
+
+    # Filter to only settings the model supports
+    effective_settings = {}
+    for setting_name, value in settings.items():
+        if _config.model_supports_setting(model_name, setting_name):
+            # Convert seed to int, keep others as float
+            if setting_name == "seed" and value is not None:
+                effective_settings[setting_name] = int(value)
+            else:
+                effective_settings[setting_name] = value
+
+    return effective_settings
+
+
+def get_effective_temperature(model_name: str | None = None) -> float | None:
+    """Get the effective temperature for a model.
+
+    Checks per-model settings first, then falls back to global temperature.
+
+    Args:
+        model_name: The model name. If None, uses the current global model.
+
+    Returns:
+        Temperature value, or None if not configured.
+    """
+    settings = _config.get_effective_model_settings(model_name)
+    return settings.get("temperature")
+
+
+def get_effective_top_p(model_name: str | None = None) -> float | None:
+    """Get the effective top_p for a model.
+
+    Args:
+        model_name: The model name. If None, uses the current global model.
+
+    Returns:
+        top_p value, or None if not configured.
+    """
+    settings = _config.get_effective_model_settings(model_name)
+    return settings.get("top_p")
+
+
+def get_effective_seed(model_name: str | None = None) -> int | None:
+    """Get the effective seed for a model.
+
+    Args:
+        model_name: The model name. If None, uses the current global model.
+
+    Returns:
+        seed value as int, or None if not configured.
+    """
+    settings = _config.get_effective_model_settings(model_name)
+    return settings.get("seed")

code_muse/config_security.py

@@ -0,0 +1,73 @@
+"""Config: security settings."""
+
+import os
+
+import code_muse.config as _config
+
+
+def get_api_key(key_name: str) -> str:
+    """Get an API key from muse.cfg.
+
+    Args:
+        key_name: The name of the API key (e.g., 'OPENAI_API_KEY')
+
+    Returns:
+        The API key value, or empty string if not set
+    """
+    return _config.get_value(key_name) or ""
+
+
+def set_api_key(key_name: str, value: str):
+    """Set an API key in muse.cfg.
+
+    Args:
+        key_name: The name of the API key (e.g., 'OPENAI_API_KEY')
+        value: The API key value (empty string to remove)
+    """
+    _config.set_config_value(key_name, value)
+
+
+def load_api_keys_to_environment():
+    """Load all API keys from .env and muse.cfg into environment variables.
+
+    Priority order:
+    1. .env file (highest priority) - if present in current directory
+    2. muse.cfg - fallback if not in .env
+    3. Existing environment variables - preserved if already set
+
+    This should be called on startup to ensure API keys are available.
+    """
+
+    api_key_names = [
+        "OPENAI_API_KEY",
+        "GEMINI_API_KEY",
+        "ANTHROPIC_API_KEY",
+        "CEREBRAS_API_KEY",
+        "SYN_API_KEY",
+        "AZURE_OPENAI_API_KEY",
+        "AZURE_OPENAI_ENDPOINT",
+        "OPENROUTER_API_KEY",
+        "ZAI_API_KEY",
+    ]
+
+    # Step 1: Load from .env file if it exists (highest priority)
+    # Look for .env in current working directory
+    env_file = _config.Path.cwd() / ".env"
+    if env_file.exists():
+        try:
+            from dotenv import load_dotenv
+
+            # override=True means .env values take precedence over existing env vars
+            load_dotenv(env_file, override=True)
+        except ImportError:
+            # python-dotenv not installed, skip .env loading
+            pass
+
+    # Step 2: Load from muse.cfg, but only if not already set
+    # This ensures .env has priority over muse.cfg
+    for key_name in api_key_names:
+        # Only load from config if not already in environment
+        if key_name not in os.environ or not os.environ[key_name]:
+            value = get_api_key(key_name)
+            if value:
+                os.environ[key_name] = value

code_muse/error_logging.py

@@ -0,0 +1,132 @@
+"""Error logging utility for code_muse.
+
+Logs unexpected errors to XDG_STATE_HOME/code_muse/logs/ for debugging purposes.
+Per XDG spec, logs are "state data" (actions history), not configuration.
+Because even good agents make mistakes sometimes!
+"""
+
+import os
+import traceback
+from datetime import datetime
+from pathlib import Path
+
+from code_muse.config import STATE_DIR
+
+# Logs directory within the state directory (per XDG spec, logs are state data)
+LOGS_DIR = STATE_DIR / "logs"
+ERROR_LOG_FILE = LOGS_DIR / "errors.log"
+MAX_LOG_SIZE = 5 * 1024 * 1024  # 5MB
+
+
+def _rotate_log_if_needed() -> None:
+    """Rotate the error log file if it exceeds MAX_LOG_SIZE."""
+    try:
+        if ERROR_LOG_FILE.exists() and ERROR_LOG_FILE.stat().st_size > MAX_LOG_SIZE:
+            rotated = str(ERROR_LOG_FILE) + ".1"
+            os.replace(ERROR_LOG_FILE, rotated)
+    except OSError:
+        pass
+
+
+def _ensure_logs_dir() -> None:
+    """Create the logs directory if it doesn't exist (with 0700 perms per XDG spec)."""
+    Path(LOGS_DIR).mkdir(parents=True, exist_ok=True, mode=0o700)
+
+
+def log_error(
+    error: Exception,
+    context: str | None = None,
+    include_traceback: bool = True,
+) -> None:
+    """Log an error to the error log file.
+
+    Args:
+        error: The exception to log
+        context: Optional context string describing where the error occurred
+        include_traceback: Whether to include the full traceback (default True)
+    """
+    try:
+        _ensure_logs_dir()
+        _rotate_log_if_needed()
+
+        timestamp = datetime.now().isoformat()
+        error_type = type(error).__name__
+        error_msg = str(error)
+
+        log_entry_parts = [
+            # TODO: PEP 750 t-string — use templatelib when stable
+            f"\n{'=' * 80}",
+            f"Timestamp: {timestamp}",
+            f"Error Type: {error_type}",
+            f"Error Message: {error_msg}",
+        ]
+
+        if context:
+            log_entry_parts.append(f"Context: {context}")
+
+        if include_traceback:
+            tb = traceback.format_exception(type(error), error, error.__traceback__)
+            log_entry_parts.append(f"Traceback:\n{''.join(tb)}")
+
+        if hasattr(error, "args") and error.args:
+            log_entry_parts.append(f"Args: {error.args}")
+
+        log_entry_parts.append(f"{'=' * 80}\n")
+
+        log_entry = "\n".join(log_entry_parts)
+
+        with open(ERROR_LOG_FILE, "a", encoding="utf-8") as f:
+            f.write(log_entry)
+
+    except Exception:
+        # If we can't log, we silently fail - don't want logging errors
+        # to cause more problems than they solve!
+        pass
+
+
+def log_error_message(
+    message: str,
+    context: str | None = None,
+) -> None:
+    """Log a simple error message without an exception object.
+
+    Args:
+        message: The error message to log
+        context: Optional context string describing where the error occurred
+    """
+    try:
+        _ensure_logs_dir()
+        _rotate_log_if_needed()
+
+        timestamp = datetime.now().isoformat()
+
+        log_entry_parts = [
+            # TODO: PEP 750 t-string — use templatelib when stable
+            f"\n{'=' * 80}",
+            f"Timestamp: {timestamp}",
+            f"Message: {message}",
+        ]
+
+        if context:
+            log_entry_parts.append(f"Context: {context}")
+
+        log_entry_parts.append(f"{'=' * 80}\n")
+
+        log_entry = "\n".join(log_entry_parts)
+
+        with open(ERROR_LOG_FILE, "a", encoding="utf-8") as f:
+            f.write(log_entry)
+
+    except Exception:
+        # Silent fail - same reasoning as above
+        pass
+
+
+def get_log_file_path() -> str:
+    """Return the path to the error log file."""
+    return ERROR_LOG_FILE
+
+
+def get_logs_dir() -> str:
+    """Return the path to the logs directory."""
+    return LOGS_DIR

code_muse/evals/__init__.py

@@ -0,0 +1,35 @@
+"""Behavioral Eval Framework for Muse.
+
+Standalone test framework for evaluating agent behavior through
+subprocess-based end-to-end testing with tool-call assertions.
+"""
+
+from code_muse.evals.eval_helpers import (
+    assert_output_contains,
+    assert_read_is_ranged,
+    assert_shell_has_flag,
+    assert_tool_called,
+    assert_tool_not_called,
+)
+from code_muse.evals.eval_runner import (
+    EvalResult,
+    EvalSuite,
+    TestRig,
+    ToolCall,
+    run_all_evals,
+    run_eval,
+)
+
+__all__ = [
+    "ToolCall",
+    "TestRig",
+    "EvalResult",
+    "run_eval",
+    "run_all_evals",
+    "EvalSuite",
+    "assert_tool_called",
+    "assert_tool_not_called",
+    "assert_shell_has_flag",
+    "assert_read_is_ranged",
+    "assert_output_contains",
+]

code_muse/evals/eval_helpers.py

@@ -0,0 +1,81 @@
+"""Assertion helpers for the Behavioral Eval Framework.
+
+Each helper inspects a :class:`TestRig` and returns ``(passed, message)``.
+"""
+
+from code_muse.evals.eval_runner import TestRig
+
+
+def assert_tool_called(
+    rig: TestRig, tool_name: str, min_count: int = 1
+) -> tuple[bool, str]:
+    """Check that *tool_name* was called at least *min_count* times."""
+    calls = rig.get_tool_calls_by_name(tool_name)
+    if len(calls) >= min_count:
+        return True, f"'{tool_name}' called {len(calls)} time(s) (≥ {min_count})"
+    return (
+        False,
+        f"Expected '{tool_name}' to be called ≥ {min_count} time(s), got {len(calls)}",
+    )
+
+
+def assert_tool_not_called(rig: TestRig, tool_name: str) -> tuple[bool, str]:
+    """Check that *tool_name* was never called."""
+    calls = rig.get_tool_calls_by_name(tool_name)
+    if not calls:
+        return True, f"'{tool_name}' was not called"
+    return (
+        False,
+        f"Expected '{tool_name}' to not be called, got {len(calls)} call(s)",
+    )
+
+
+def assert_shell_has_flag(rig: TestRig, flag: str) -> tuple[bool, str]:
+    """Check that shell commands include a specific flag (e.g. ``--silent``)."""
+    shell_calls = rig.get_tool_calls_by_name("agent_run_shell_command")
+    for tc in shell_calls:
+        command = tc.tool_args.get("command", "")
+        if flag in command:
+            return True, f"Shell command contains flag '{flag}'"
+    return (
+        False,
+        f"No shell command contained flag '{flag}' among {len(shell_calls)} call(s)",
+    )
+
+
+def assert_read_is_ranged(rig: TestRig) -> tuple[bool, str]:
+    """Check that ``read_file`` calls use ``start_line``/``num_lines``."""
+    read_calls = rig.get_tool_calls_by_name("read_file")
+    if not read_calls:
+        return False, "No 'read_file' calls observed"
+
+    ranged = 0
+    for tc in read_calls:
+        if (
+            tc.tool_args.get("start_line") is not None
+            or tc.tool_args.get("num_lines") is not None
+        ):
+            ranged += 1
+
+    if ranged == len(read_calls):
+        return True, f"All {len(read_calls)} 'read_file' call(s) used range parameters"
+    return (
+        False,
+        f"Only {ranged}/{len(read_calls)} 'read_file' call(s) used range parameters",
+    )
+
+
+def assert_output_contains(rig: TestRig, text: str) -> tuple[bool, str]:
+    """Check that the combined stdout/stderr captured during the eval contains *text*.
+
+    Note: This helper requires that the :class:`TestRig` was populated
+    with a synthetic ``output`` tool call by :func:`run_eval` (the
+    framework injects one when a ``_raw_output`` key is present).
+    """
+    output_calls = rig.get_tool_calls_by_name("_eval_output")
+    if not output_calls:
+        return False, "No eval output captured (internal)"
+    combined = output_calls[0].result or ""
+    if text in combined:
+        return True, f"Output contains '{text}'"
+    return False, f"Output does not contain '{text}'"