priests 0.4.0__py3-none-any.whl

priests/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.1.0"

priests/cli/config_cmd.py

@@ -0,0 +1,58 @@
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Annotated
+
+import tomli_w
+import typer
+from rich.console import Console
+from rich.syntax import Syntax
+
+from priests.config.loader import is_initialized, load_config, set_config_value
+
+config_app = typer.Typer(help="View and edit configuration.")
+console = Console()
+err_console = Console(stderr=True)
+
+
+def _strip_none(obj):
+    """Recursively remove None values — TOML has no null type."""
+    if isinstance(obj, dict):
+        return {k: _strip_none(v) for k, v in obj.items() if v is not None}
+    return obj
+
+
+@config_app.command("show")
+def config_show(
+    config_file: Annotated[Path | None, typer.Option("--config", help="Path to priests.toml.")] = None,
+) -> None:
+    """Print the current resolved configuration."""
+    if not is_initialized(config_file):
+        err_console.print("[yellow]Not initialized.[/yellow] Run [bold]priests init[/bold] first.")
+        raise typer.Exit(1)
+    config = load_config(config_file)
+    raw = _strip_none(config.model_dump(mode="json"))
+    toml_str = tomli_w.dumps(raw)
+    console.print(Syntax(toml_str, "toml", theme="ansi_dark", background_color="default"))
+
+
+@config_app.command("set")
+def config_set(
+    key: Annotated[str, typer.Argument(help="Dotted key, e.g. default.model or service.port.")],
+    value: Annotated[str, typer.Argument(help="New value.")],
+    config_file: Annotated[Path | None, typer.Option("--config", help="Path to priests.toml.")] = None,
+) -> None:
+    """Set a configuration value and save it."""
+    if not is_initialized(config_file):
+        err_console.print("[yellow]Not initialized.[/yellow] Run [bold]priests init[/bold] first.")
+        raise typer.Exit(1)
+    try:
+        saved_path = set_config_value(key, value, config_file)
+        console.print(f"[green]Set[/green] {key} = {value!r}")
+        console.print(f"[dim]Saved to {saved_path}[/dim]")
+    except KeyError as e:
+        err_console.print(f"[red]Error:[/red] {e}")
+        raise typer.Exit(1)
+    except (ValueError, TypeError) as e:
+        err_console.print(f"[red]Invalid value:[/red] {e}")
+        raise typer.Exit(1)

priests/cli/init_cmd.py

@@ -0,0 +1,193 @@
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Annotated
+
+import httpx
+import questionary
+import typer
+from rich.console import Console
+
+from priests.config.loader import is_initialized, save_config
+from priests.config.model import (
+    AnthropicConfig,
+    AppConfig,
+    DefaultsConfig,
+    OllamaConfig,
+    OpenAICompatConfig,
+    PathsConfig,
+    ProvidersConfig,
+    ServiceConfig,
+)
+from priests.engine_factory import _bootstrap_profiles
+from priests.registry import ProviderInfo, get_provider, list_providers
+
+console = Console()
+err_console = Console(stderr=True)
+
+
+def _arrow_select(prompt: str, choices: list[questionary.Choice]) -> str:
+    """Arrow-key selection. Aborts with a clean message on Ctrl-C."""
+    result = questionary.select(prompt, choices=choices, use_shortcuts=False).ask()
+    if result is None:
+        raise typer.Abort()
+    return result
+
+
+def _fetch_ollama_models(base_url: str) -> list[str] | None:
+    """Return sorted model names from Ollama, or None if unreachable."""
+    try:
+        r = httpx.get(f"{base_url.rstrip('/')}/api/tags", timeout=5.0)
+        r.raise_for_status()
+        return sorted(m["name"] for m in r.json().get("models", []))
+    except Exception:
+        return None
+
+
+def _select_ollama_model(default_url: str) -> tuple[str, str]:
+    """Return (model_name, confirmed_base_url). Retries on bad URL."""
+    base_url = default_url
+
+    while True:
+        console.print(f"[dim]Connecting to Ollama at {base_url} ...[/dim]")
+        models = _fetch_ollama_models(base_url)
+
+        if models is None:
+            err_console.print(f"[red]Could not connect to Ollama at {base_url}[/red]")
+            base_url = typer.prompt("Enter Ollama base URL").strip().rstrip("/")
+            continue
+
+        if not models:
+            console.print("[yellow]No local models found.[/yellow] Make sure you have pulled at least one model.")
+            console.print("  e.g. [bold]ollama pull qwen3:8b[/bold]\n")
+            model = typer.prompt("Or enter a model name manually").strip()
+            return model, base_url
+
+        model = _arrow_select(
+            "Select model:",
+            [questionary.Choice(title=m) for m in models],
+        )
+        return model, base_url
+
+
+def _select_model(info: ProviderInfo) -> str:
+    """Select a model for a non-Ollama provider.
+
+    Shows an arrow selector when known_models is non-empty, with an
+    'Enter manually' escape hatch. Falls back to free-text when the list
+    is empty (OpenRouter, Custom).
+    """
+    if not info.known_models:
+        return typer.prompt("Model name").strip()
+
+    _MANUAL = "__manual__"
+    choices = [questionary.Choice(title=m) for m in info.known_models]
+    choices.append(questionary.Choice(title="Enter manually…", value=_MANUAL))
+
+    selected = _arrow_select("Select model:", choices)
+    if selected == _MANUAL:
+        return typer.prompt("Model name").strip()
+    return selected
+
+
+def _register_model(config: AppConfig, provider: str, model: str) -> None:
+    """Add provider/model to config.models.options if not already present."""
+    entry = f"{provider}/{model}"
+    if entry not in config.models.options:
+        config.models.options.append(entry)
+
+
+def _apply_provider_to_config(
+    providers: ProvidersConfig,
+    provider: str,
+    api_key: str,
+    custom_base_url: str,
+) -> None:
+    """Write api_key (and base_url for custom) into the providers config in-place."""
+    if provider == "anthropic":
+        providers.anthropic = AnthropicConfig(api_key=api_key)
+    elif provider == "custom":
+        providers.custom = OpenAICompatConfig(api_key=api_key, base_url=custom_base_url)
+    elif provider != "ollama":
+        info = get_provider(provider)
+        base_url = info.default_base_url if info else ""
+        setattr(providers, provider, OpenAICompatConfig(api_key=api_key, base_url=base_url))
+
+
+def init_command(
+    force: Annotated[bool, typer.Option("--force", help="Re-initialize even if already set up.")] = False,
+    config_file: Annotated[Path | None, typer.Option("--config", help="Path to priests.toml.")] = None,
+) -> None:
+    """Initialize priests: configure provider, model, and scaffold profiles."""
+    if is_initialized(config_file) and not force:
+        console.print("[yellow]priests is already initialized.[/yellow]")
+        console.print("Run [bold]priests config show[/bold] to see current settings.")
+        console.print("Use [bold]--force[/bold] to re-initialize.")
+        raise typer.Exit()
+
+    console.print("[bold]Welcome to priests![/bold]")
+    console.print("Let's set up your configuration.\n")
+
+    # --- Provider ---
+    providers_list = list_providers()
+    provider_name = _arrow_select(
+        "Select a provider:",
+        [questionary.Choice(title=f"{p.name}  —  {p.label}", value=p.name) for p in providers_list],
+    )
+    console.print()
+
+    info = next(p for p in providers_list if p.name == provider_name)
+
+    # --- API key + model ---
+    ollama_base_url = "http://localhost:11434"
+    api_key = ""
+    custom_base_url = ""
+
+    if provider_name == "ollama":
+        model, ollama_base_url = _select_ollama_model(ollama_base_url)
+    else:
+        if provider_name == "custom":
+            custom_base_url = typer.prompt("Base URL (e.g. https://my-server/v1)").strip().rstrip("/")
+        if info.needs_api_key:
+            api_key = typer.prompt("API key", hide_input=False).strip()
+        model = _select_model(info)
+
+    console.print()
+
+    # --- Paths ---
+    default_profiles_dir = str(Path.home() / ".priests" / "profiles")
+    default_sessions_db = str(Path.home() / ".priests" / "sessions.db")
+
+    profiles_dir_str = typer.prompt("Profiles directory", default=default_profiles_dir)
+    sessions_db_str = typer.prompt("Sessions database", default=default_sessions_db)
+
+    # --- Build and save config ---
+    providers = ProvidersConfig(ollama=OllamaConfig(base_url=ollama_base_url))
+    _apply_provider_to_config(providers, provider_name, api_key, custom_base_url)
+
+    config = AppConfig(
+        default=DefaultsConfig(provider=provider_name, model=model),
+        paths=PathsConfig(
+            profiles_dir=Path(profiles_dir_str),
+            sessions_db=Path(sessions_db_str),
+        ),
+        service=ServiceConfig(),
+        providers=providers,
+    )
+
+    _register_model(config, provider_name, model)
+    saved_path = save_config(config, config_file)
+
+    profiles_root = Path(profiles_dir_str).expanduser()
+    _bootstrap_profiles(profiles_root)
+
+    console.print(f"\n[green]Initialized![/green] Config saved to {saved_path}")
+    console.print(f"  provider : {provider_name}")
+    console.print(f"  model    : {model}")
+    console.print(f"  profiles : {profiles_root}")
+    console.print("\n[bold]Next steps:[/bold]")
+    console.print("  [bold]priests run[/bold]                          start an interactive chat")
+    console.print("  [bold]priests run --prompt \"...\"[/bold]           send a single prompt")
+    console.print("  [bold]priests profile init \"my_profile\"[/bold]    create a custom profile")
+    console.print("  [bold]priests model add[/bold]                     configure an additional provider")
+    console.print("  [bold]priests --help[/bold]  /  [bold]priests <command> --help[/bold]")

priests/cli/main.py

@@ -0,0 +1,49 @@
+from __future__ import annotations
+
+import typer
+from typer.core import TyperGroup
+
+from priests import __version__
+from priests.cli.init_cmd import init_command
+from priests.cli.run_cmd import run_app
+from priests.cli.profile_cmd import profile_app
+from priests.cli.config_cmd import config_app
+from priests.cli.model_cmd import model_app
+from priests.cli.providers_cmd import providers_app
+from priests.cli.service_cmd import service_app
+
+
+class _DefaultRunGroup(TyperGroup):
+    """Route unknown subcommands to 'run' so `priests "prompt"` works as a shortcut."""
+
+    def resolve_command(self, ctx, args: list) -> tuple:
+        cmd_name = args[0] if args else None
+        if cmd_name and cmd_name not in self.commands:
+            args.insert(0, "run")
+        return super().resolve_command(ctx, args)
+
+
+app = typer.Typer(
+    name="priests",
+    help="AI dispatch CLI and service.",
+    no_args_is_help=True,
+    cls=_DefaultRunGroup,
+)
+
+app.command("init")(init_command)
+app.add_typer(run_app, name="run")
+app.add_typer(profile_app, name="profile")
+app.add_typer(config_app, name="config")
+app.add_typer(model_app, name="model")
+app.add_typer(providers_app, name="providers")
+app.add_typer(service_app, name="service")
+
+
+@app.callback(invoke_without_command=True)
+def root(
+    ctx: typer.Context,
+    version: bool = typer.Option(False, "--version", "-V", is_eager=True, help="Show version and exit."),
+) -> None:
+    if version:
+        typer.echo(f"priests {__version__}")
+        raise typer.Exit()

priests/cli/model_cmd.py

@@ -0,0 +1,125 @@
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Annotated
+
+import questionary
+import typer
+from rich.console import Console
+
+from priests.cli.init_cmd import (
+    _apply_provider_to_config,
+    _arrow_select,
+    _register_model,
+    _select_model,
+    _select_ollama_model,
+)
+from priests.config.loader import is_initialized, load_config, save_config
+from priests.registry import list_providers
+
+model_app = typer.Typer(help="Manage model defaults and provider setup.")
+console = Console()
+err_console = Console(stderr=True)
+
+_ADD_NEW = "__add_new__"
+
+
+@model_app.command("list")
+def model_list(
+    config_file: Annotated[Path | None, typer.Option("--config", help="Path to priests.toml.")] = None,
+) -> None:
+    """List all added models."""
+    if not is_initialized(config_file):
+        err_console.print("[yellow]Not initialized.[/yellow] Run [bold]priests init[/bold] first.")
+        raise typer.Exit(1)
+
+    config = load_config(config_file)
+    if not config.models.options:
+        console.print("[dim]No models added yet. Run [bold]priests model add[/bold].[/dim]")
+        return
+
+    for entry in config.models.options:
+        marker = "[green]*[/green] " if entry == f"{config.default.provider}/{config.default.model}" else "  "
+        console.print(f"{marker}{entry}")
+
+
+@model_app.command("default")
+def model_default(
+    config_file: Annotated[Path | None, typer.Option("--config", help="Path to priests.toml.")] = None,
+) -> None:
+    """Set the default model from your added models list."""
+    if not is_initialized(config_file):
+        err_console.print("[yellow]Not initialized.[/yellow] Run [bold]priests init[/bold] first.")
+        raise typer.Exit(1)
+
+    config = load_config(config_file)
+
+    if config.models.options:
+        choices = [questionary.Choice(title=m) for m in config.models.options]
+        choices.append(questionary.Choice(title="Add new model…", value=_ADD_NEW))
+        selected = _arrow_select("Select default model:", choices)
+    else:
+        selected = _ADD_NEW
+
+    if selected == _ADD_NEW:
+        provider_name, model = _run_add_flow(config, config_file)
+    else:
+        provider_name, model = selected.split("/", 1)
+
+    config.default.provider = provider_name
+    config.default.model = model
+
+    saved_path = save_config(config, config_file)
+    console.print(f"\n[green]Default updated.[/green] Saved to {saved_path}")
+    console.print(f"  {provider_name}/{model}")
+
+
+@model_app.command("add")
+def model_add(
+    config_file: Annotated[Path | None, typer.Option("--config", help="Path to priests.toml.")] = None,
+) -> None:
+    """Configure an additional provider and add a model to your list."""
+    if not is_initialized(config_file):
+        err_console.print("[yellow]Not initialized.[/yellow] Run [bold]priests init[/bold] first.")
+        raise typer.Exit(1)
+
+    config = load_config(config_file)
+    provider_name, model = _run_add_flow(config, config_file)
+
+    console.print(f"\n[green]Model added.[/green]  {provider_name}/{model}")
+    console.print(f"[dim]Use with: priests run --provider {provider_name} --model {model}[/dim]")
+    console.print(f"[dim]Set as default: priests model default[/dim]")
+
+
+def _run_add_flow(config, config_file) -> tuple[str, str]:
+    """Shared flow: select provider, enter key, select model, save. Returns (provider, model)."""
+    all_providers = list_providers()
+    provider_name = _arrow_select(
+        "Select provider:",
+        [questionary.Choice(title=f"{p.name}  —  {p.label}", value=p.name) for p in all_providers],
+    )
+    console.print()
+
+    info = next(p for p in all_providers if p.name == provider_name)
+
+    if provider_name == "ollama":
+        current_url = config.providers.ollama.base_url
+        model, ollama_base_url = _select_ollama_model(current_url)
+        config.providers.ollama.base_url = ollama_base_url
+        api_key = ""
+        custom_base_url = ""
+    else:
+        custom_base_url = ""
+        if provider_name == "custom":
+            current_url = config.providers.custom.base_url if config.providers.custom else ""
+            custom_base_url = typer.prompt("Base URL", default=current_url or "https://").strip().rstrip("/")
+        api_key = ""
+        if info.needs_api_key:
+            api_key = typer.prompt("API key").strip()
+        model = _select_model(info)
+
+    _apply_provider_to_config(config.providers, provider_name, api_key, custom_base_url)
+    _register_model(config, provider_name, model)
+    save_config(config, config_file)
+
+    return provider_name, model

priests/cli/profile_cmd.py

@@ -0,0 +1,103 @@
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Annotated
+
+import typer
+from rich.console import Console
+from rich.table import Table
+
+from priests.config.loader import load_config
+
+profile_app = typer.Typer(help="Manage profiles.")
+console = Console()
+err_console = Console(stderr=True)
+
+_PROFILE_MD_STUB = """\
+# {name}
+
+You are a helpful assistant.
+"""
+
+_PROFILE_TOML_STUB = """\
+# Profile settings for {name}
+
+# Set to false to disable memory loading and saving for this profile.
+# Useful for tool profiles (dictionary, formatter, etc.) that don't need user memory.
+memories = true
+
+# Override the global memory limit for this profile (number of auto_YYYYMMDD.md files to keep).
+# Uncomment to override.
+# memories_limit = 50
+"""
+
+_RULES_MD_STUB = """\
+# Rules
+
+Be honest. Do not make things up.
+Be concise unless the user asks for depth.
+
+## Memory
+
+Define what this profile should remember and how.
+- Use `<memory type="user">` for stable facts about the user (name, preferences, background).
+- Use `<memory type="note">` for role-important things (e.g. birthdays, key constraints).
+- Use `<memory>` for daily observations and short-term context.
+
+Replace this section with specific guidance for this profile's role.
+"""
+
+
+@profile_app.command("list")
+def profile_list(
+    profiles_dir: Annotated[Path | None, typer.Option("--profiles-dir", help="Profiles directory.")] = None,
+    config_file: Annotated[Path | None, typer.Option("--config", help="Path to priests.toml.")] = None,
+) -> None:
+    """List available profiles."""
+    config = load_config(config_file)
+    root = (profiles_dir or config.paths.profiles_dir).expanduser()
+
+    if not root.exists():
+        console.print(f"[dim]Profiles directory not found: {root}[/dim]")
+        console.print("[dim]Use 'priests profile init NAME' to create your first profile.[/dim]")
+        return
+
+    profiles = sorted(
+        d.name for d in root.iterdir() if d.is_dir() and (d / "PROFILE.md").exists()
+    )
+
+    if not profiles:
+        console.print(f"[dim]No profiles found in {root}[/dim]")
+        return
+
+    table = Table(show_header=False, box=None, pad_edge=False)
+    for name in profiles:
+        table.add_row(f"  {name}")
+
+    console.print(table)
+
+
+@profile_app.command("init")
+def profile_init(
+    name: Annotated[str, typer.Argument(help="Profile name to create.")],
+    profiles_dir: Annotated[Path | None, typer.Option("--profiles-dir", help="Profiles directory.")] = None,
+    config_file: Annotated[Path | None, typer.Option("--config", help="Path to priests.toml.")] = None,
+) -> None:
+    """Scaffold a new profile directory."""
+    config = load_config(config_file)
+    root = (profiles_dir or config.paths.profiles_dir).expanduser()
+    profile_dir = root / name
+
+    if profile_dir.exists():
+        err_console.print(f"[red]Profile '{name}' already exists at {profile_dir}[/red]")
+        raise typer.Exit(1)
+
+    profile_dir.mkdir(parents=True)
+    (profile_dir / "PROFILE.md").write_text(_PROFILE_MD_STUB.format(name=name))
+    (profile_dir / "RULES.md").write_text(_RULES_MD_STUB)
+    (profile_dir / "CUSTOM.md").write_text("")
+    (profile_dir / "profile.toml").write_text(_PROFILE_TOML_STUB.format(name=name))
+    (profile_dir / "memories").mkdir()
+
+    console.print(f"[green]Created profile '{name}'[/green] at {profile_dir}")
+    console.print(f"  Edit [bold]{profile_dir / 'PROFILE.md'}[/bold] to define the identity.")

priests/cli/providers_cmd.py

@@ -0,0 +1,86 @@
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Annotated
+
+import typer
+from rich.console import Console
+from rich.table import Table
+
+from priests.cli.init_cmd import _fetch_ollama_models
+from priests.config.loader import load_config
+from priests.registry import get_provider, list_providers
+
+providers_app = typer.Typer(help="List available providers and their models.")
+console = Console()
+err_console = Console(stderr=True)
+
+
+@providers_app.callback(invoke_without_command=True)
+def providers_list(
+    ctx: typer.Context,
+    config_file: Annotated[Path | None, typer.Option("--config", help="Path to priests.toml.")] = None,
+) -> None:
+    """List all supported providers."""
+    if ctx.invoked_subcommand is not None:
+        return
+
+    config = load_config(config_file)
+
+    table = Table(show_header=True, header_style="bold", box=None, pad_edge=False, min_width=60)
+    table.add_column("Provider", style="bold", min_width=16)
+    table.add_column("Label")
+    table.add_column("Configured", justify="center", min_width=12)
+
+    for info in list_providers():
+        if info.name == "ollama":
+            configured = "[green]local[/green]"
+        else:
+            cfg = getattr(config.providers, info.name, None)
+            configured = "[green]yes[/green]" if (cfg and getattr(cfg, "api_key", None)) else "[dim]no[/dim]"
+
+        table.add_row(info.name, info.label, configured)
+
+    console.print(table)
+    console.print(f"\n[dim]Run [bold]priests providers <name>[/bold] to list models.[/dim]")
+
+
+@providers_app.command("models")
+def provider_models(
+    name: Annotated[str, typer.Argument(help="Provider name (e.g. openai, groq, ollama).")],
+    config_file: Annotated[Path | None, typer.Option("--config", help="Path to priests.toml.")] = None,
+) -> None:
+    """List known models for a provider."""
+    info = get_provider(name)
+    if info is None:
+        err_console.print(f"[red]Unknown provider:[/red] {name}")
+        err_console.print(f"[dim]Run [bold]priests providers[/bold] to see available providers.[/dim]")
+        raise typer.Exit(1)
+
+    console.print(f"[bold]{info.name}[/bold]  —  {info.label}\n")
+
+    if info.known_models is None:
+        # Ollama: fetch dynamically
+        config = load_config(config_file)
+        base_url = config.providers.ollama.base_url
+        console.print(f"[dim]Fetching models from {base_url} ...[/dim]")
+        models = _fetch_ollama_models(base_url)
+        if models is None:
+            err_console.print(f"[red]Could not connect to Ollama at {base_url}[/red]")
+            raise typer.Exit(1)
+        if not models:
+            console.print("[yellow]No models found.[/yellow] Pull one with [bold]ollama pull <model>[/bold].")
+            return
+        for m in models:
+            console.print(f"  {m}")
+        return
+
+    if not info.known_models:
+        console.print("[dim]No curated model list — enter the model name manually.[/dim]")
+        if name == "openrouter":
+            console.print("[dim]Browse models at https://openrouter.ai/models[/dim]")
+        return
+
+    for m in info.known_models:
+        console.print(f"  {m}")
+    console.print(f"\n[dim]Use: [bold]priests run --provider {name} --model <model>[/bold][/dim]")