review comments

Signed-off-by: Paul S. Schweigert <paul@paulschweigert.com>

Author: psschwei

cli/config/commands.py

@@ -7,45 +7,13 @@
 from rich.syntax import Syntax
 from rich.table import Table
 
-from mellea.config import (
-    find_config_file,
-    get_config_path,
-    get_user_config_dir,
-    init_project_config,
-    init_user_config,
-    load_config,
-)
+from mellea.config import find_config_file, init_project_config, load_config
 
 config_app = typer.Typer(name="config", help="Manage Mellea configuration files")
 console = Console()
 
 
 @config_app.command("init")
-def init_user(
-    force: bool = typer.Option(
-        False, "--force", "-f", help="Overwrite existing config file"
-    ),
-) -> None:
-    """Create a user configuration file at ~/.config/mellea/config.toml."""
-    try:
-        config_path = init_user_config(force=force)
-        console.print(f"[green]✓[/green] Created user config at: {config_path}")
-        console.print(
-            "\nEdit this file to set your default backend, model, and credentials."
-        )
-        console.print(
-            "Run [cyan]m config show[/cyan] to view the current configuration."
-        )
-    except FileExistsError as e:
-        console.print(f"[red]✗[/red] {e}")
-        console.print("Use [cyan]--force[/cyan] to overwrite the existing file.")
-        raise typer.Exit(1)
-    except Exception as e:
-        console.print(f"[red]✗[/red] Error creating config: {e}")
-        raise typer.Exit(1)
-
-
-@config_app.command("init-project")
 def init_project(
     force: bool = typer.Option(
         False, "--force", "-f", help="Overwrite existing config file"
@@ -55,9 +23,9 @@ def init_project(
     try:
         config_path = init_project_config(force=force)
         console.print(f"[green]✓[/green] Created project config at: {config_path}")
-        console.print("\nThis config will override user settings for this project.")
+        console.print("\nEdit this file to set your backend, model, and other options.")
         console.print(
-            "Run [cyan]m config show[/cyan] to view the effective configuration."
+            "Run [cyan]m config show[/cyan] to view the current configuration."
         )
     except FileExistsError as e:
         console.print(f"[red]✗[/red] {e}")
@@ -126,10 +94,6 @@ def show_config() -> None:
 
         console.print(table)
 
-        # Show search order
-        console.print("\n[bold]Configuration search order:[/bold]")
-        console.print("1. Project config: ./mellea.toml (current dir and parents)")
-        console.print(f"2. User config: {get_user_config_dir() / 'config.toml'}")
         console.print(
             "\n[dim]Explicit parameters in code override config file values.[/dim]"
         )
@@ -156,12 +120,9 @@ def show_path() -> None:
             console.print(syntax)
         else:
             console.print("[yellow]No configuration file found.[/yellow]")
-            console.print("\nSearched locations:")
-            console.print("1. ./mellea.toml (current dir and parents)")
-            console.print(f"2. {get_user_config_dir() / 'config.toml'}")
-            console.print("\nRun [cyan]m config init[/cyan] to create a user config.")
+            console.print("\nSearched: ./mellea.toml (current dir and parents)")
             console.print(
-                "Run [cyan]m config init-project[/cyan] to create a project config."
+                "\nRun [cyan]m config init[/cyan] to create a project config."
             )
     except Exception as e:
         console.print(f"[red]✗[/red] Error: {e}")
@@ -170,37 +131,27 @@ def show_path() -> None:
 
 @config_app.command("where")
 def show_locations() -> None:
-    """Show all possible configuration file locations."""
-    user_config_dir = get_user_config_dir()
-    user_config_path = user_config_dir / "config.toml"
+    """Show configuration file location."""
     project_config_path = Path.cwd() / "mellea.toml"
 
-    console.print("[bold]Configuration file locations:[/bold]\n")
-
-    # User config
-    console.print(f"[cyan]User config:[/cyan] {user_config_path}")
-    if user_config_path.exists():
-        console.print("  [green]✓ exists[/green]")
-    else:
-        console.print("  [dim]✗ not found[/dim]")
-        console.print("  Run [cyan]m config init[/cyan] to create")
-
-    console.print()
+    console.print("[bold]Configuration file location:[/bold]\n")
 
     # Project config
     console.print(f"[cyan]Project config:[/cyan] {project_config_path}")
     if project_config_path.exists():
         console.print("  [green]✓ exists[/green]")
     else:
         console.print("  [dim]✗ not found[/dim]")
-        console.print("  Run [cyan]m config init-project[/cyan] to create")
+        console.print("  Run [cyan]m config init[/cyan] to create")
 
     console.print()
 
-    # Currently loaded
+    # Currently loaded (might be in parent dir)
     current = find_config_file()
     if current:
         console.print(f"[bold green]Currently loaded:[/bold green] {current}")
+        if current != project_config_path:
+            console.print("  [dim](found in parent directory)[/dim]")
     else:
         console.print(
             "[yellow]No config file currently loaded (using defaults)[/yellow]"

mellea/config.py

@@ -3,22 +3,20 @@
 This module provides support for TOML configuration files to set default
 backends, models, credentials, and other options without hardcoding them.
 
-Configuration files are searched in the following order:
-1. Project-specific: ./mellea.toml (current dir and parents)
-2. User config: ~/.config/mellea/config.toml (Linux/macOS) or
-   %APPDATA%\mellea\config.toml (Windows)
+Configuration files are searched for in the current directory and parent
+directories (./mellea.toml). If found, the config is used; if not, defaults
+apply.
 
 Values are applied with the following precedence:
 1. Explicit parameters passed to start_session()
 2. Project config file (if exists)
-3. User config file (if exists)
-4. Built-in defaults
+3. Built-in defaults
 """
 
 import os
 import sys
 from pathlib import Path
-from typing import Any, Optional
+from typing import Any
 
 from pydantic import BaseModel, Field
 
@@ -35,13 +33,64 @@
 
 
 class BackendConfig(BaseModel):
-    """Configuration for backend settings."""
+    """Configuration for backend settings.
+
+    Model options can be specified generically or per-backend:
+
+    ```toml
+    [backend.model_options]
+    temperature = 0.7  # applies to all backends
+
+    [backend.model_options.ollama]
+    num_ctx = 4096  # ollama-specific
+
+    [backend.model_options.openai]
+    presence_penalty = 0.5  # openai-specific
+    ```
+    """
 
     name: str | None = None
     model_id: str | None = None
     model_options: dict[str, Any] = Field(default_factory=dict)
     kwargs: dict[str, Any] = Field(default_factory=dict)
 
+    # Known backend names for detecting per-backend options
+    _BACKEND_NAMES = {
+        "ollama",
+        "hf",
+        "huggingface",
+        "openai",
+        "watsonx",
+        "litellm",
+        "vllm",
+    }
+
+    def get_model_options_for_backend(self, backend_name: str) -> dict[str, Any]:
+        """Get merged model options for a specific backend.
+
+        Merges generic options with backend-specific options.
+        Backend-specific options override generic ones.
+
+        Args:
+            backend_name: The backend name (e.g., "ollama", "openai")
+
+        Returns:
+            Merged model options dictionary
+        """
+        result = {}
+
+        # First, add generic options (non-dict values that aren't backend names)
+        for key, value in self.model_options.items():
+            if key not in self._BACKEND_NAMES and not isinstance(value, dict):
+                result[key] = value
+
+        # Then, merge backend-specific options (overrides generic)
+        backend_specific = self.model_options.get(backend_name)
+        if isinstance(backend_specific, dict):
+            result.update(backend_specific)
+
+        return result
+
 
 class CredentialsConfig(BaseModel):
     """Configuration for API credentials."""
@@ -65,50 +114,21 @@ class MelleaConfig(BaseModel):
 _config_cache: tuple[MelleaConfig, Path | None] | None = None
 
 
-def get_user_config_dir() -> Path:
-    r"""Get the user configuration directory following XDG Base Directory spec.
-
-    Returns:
-        Path to user config directory (~/.config/mellea on Linux/macOS,
-        %APPDATA%\mellea on Windows)
-    """
-    if sys.platform == "win32":
-        # Windows: use APPDATA
-        appdata = os.environ.get("APPDATA")
-        if appdata:
-            return Path(appdata) / "mellea"
-        # Fallback to user home
-        return Path.home() / "AppData" / "Roaming" / "mellea"
-    else:
-        # Linux/macOS: use XDG_CONFIG_HOME or ~/.config
-        xdg_config = os.environ.get("XDG_CONFIG_HOME")
-        if xdg_config:
-            return Path(xdg_config) / "mellea"
-        return Path.home() / ".config" / "mellea"
-
-
 def find_config_file() -> Path | None:
-    """Find configuration file in standard locations.
+    """Find configuration file in current directory or parent directories.
 
-    Searches in order:
-    1. ./mellea.toml (current directory and parents)
-    2. ~/.config/mellea/config.toml (or Windows equivalent)
+    Searches for ./mellea.toml starting from current directory and walking
+    up to parent directories.
 
     Returns:
         Path to config file if found, None otherwise
     """
-    # Search for project config (current dir and parents)
     current = Path.cwd()
     for parent in [current, *current.parents]:
         project_config = parent / "mellea.toml"
         if project_config.exists():
             return project_config
 
-    # Search for user config
-    user_config = get_user_config_dir() / "config.toml"
-    if user_config.exists():
-        return user_config
-
     return None
 
 
@@ -189,8 +209,8 @@ def apply_credentials_to_env(config: MelleaConfig) -> None:
             os.environ[env_var] = value
 
 
-def init_user_config(force: bool = False) -> Path:
-    """Create example user configuration file.
+def init_project_config(force: bool = False) -> Path:
+    """Create example project configuration file.
 
     Args:
         force: If True, overwrite existing config file
@@ -201,35 +221,37 @@ def init_user_config(force: bool = False) -> Path:
     Raises:
         FileExistsError: If config file exists and force=False
     """
-    config_dir = get_user_config_dir()
-    config_path = config_dir / "config.toml"
+    config_path = Path.cwd() / "mellea.toml"
 
     if config_path.exists() and not force:
         raise FileExistsError(
             f"Config file already exists at {config_path}. Use --force to overwrite."
         )
 
-    # Create config directory if it doesn't exist
-    config_dir.mkdir(parents=True, exist_ok=True)
-
-    # Example config content
-    example_config = """# Mellea User Configuration
-# This file sets global defaults for all projects.
-# Project-specific configs (./mellea.toml) override these settings.
+    # Example project config content
+    example_config = """# Mellea Project Configuration
+# If this file exists, it will be used to configure start_session() defaults.
+# Explicit parameters passed to start_session() override these settings.
 
 [backend]
-# Default backend to use (ollama, openai, huggingface, vllm, watsonx, litellm)
+# Backend to use (ollama, openai, huggingface, vllm, watsonx, litellm)
 name = "ollama"
 
-# Default model ID
-model_id = "granite-4-micro:3b"
+# Model ID
+model_id = "llama3.2:1b"
 
-# Default model options (temperature, max_tokens, etc.)
+# Generic model options (apply to all backends)
 [backend.model_options]
 temperature = 0.7
-max_tokens = 2048
 
-# Backend-specific options
+# Per-backend model options (override generic options for that backend)
+# [backend.model_options.ollama]
+# num_ctx = 4096
+
+# [backend.model_options.openai]
+# presence_penalty = 0.5
+
+# Backend-specific constructor options
 [backend.kwargs]
 # base_url = "http://localhost:11434"  # For Ollama
 
@@ -252,47 +274,6 @@ def init_user_config(force: bool = False) -> Path:
     return config_path
 
 
-def init_project_config(force: bool = False) -> Path:
-    """Create example project configuration file.
-
-    Args:
-        force: If True, overwrite existing config file
-
-    Returns:
-        Path to created config file
-
-    Raises:
-        FileExistsError: If config file exists and force=False
-    """
-    config_path = Path.cwd() / "mellea.toml"
-
-    if config_path.exists() and not force:
-        raise FileExistsError(
-            f"Config file already exists at {config_path}. Use --force to overwrite."
-        )
-
-    # Example project config content
-    example_config = """# Mellea Project Configuration
-# This file overrides user config (~/.config/mellea/config.toml) for this project.
-
-[backend]
-# Project-specific model
-model_id = "llama3.2:1b"
-
-[backend.model_options]
-temperature = 0.9
-
-# Project-specific context type
-context_type = "chat"
-"""
-
-    # Write config file
-    with open(config_path, "w") as f:
-        f.write(example_config)
-
-    return config_path
-
-
 def clear_config_cache() -> None:
     """Clear the cached configuration.