cecli-dev 1.5.0rc4__tar.gz → 1.5.0rc5__tar.gz

{cecli_dev-1.5.0rc4 → cecli_dev-1.5.0rc5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cecli-dev
-Version: 1.5.0rc4
+Version: 1.5.0rc5
 Summary: we also can't pronounce cecli
 Project-URL: Homepage, https://github.com/dwash96/cecli
 Project-URL: Documentation, https://github.com/dwash96/cecli

{cecli_dev-1.5.0rc4 → cecli_dev-1.5.0rc5}/cecli/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '1.5.0rc4'
-__version_tuple__ = version_tuple = (1, 5, 0, 'rc4')
+__version__ = version = '1.5.0rc5'
+__version_tuple__ = version_tuple = (1, 5, 0, 'rc5')
 
-__commit_id__ = commit_id = 'gd6d4059fc'
+__commit_id__ = commit_id = 'g9fb17f68d'

{cecli_dev-1.5.0rc4 → cecli_dev-1.5.0rc5}/cecli/helpers/model_providers.py

@@ -173,6 +173,28 @@ class ModelProviderManager:
                     listings[model_id] = info
         return listings
 
+    def get_provider_models(self, provider: str) -> Dict[str, Dict]:
+        """Return ``{model_id: info}`` for a single provider.
+
+        Unlike :meth:`get_models_for_listing`, this only resolves and fetches the
+        requested provider, so it is safe to call during onboarding right after
+        an API key has been supplied (the key must already be in the environment).
+        """
+        if not provider or not self._ensure_provider_state(provider):
+            return {}
+        content = self._ensure_content(provider)
+        if not content or "data" not in content:
+            return {}
+        listings = {}
+        for record in content["data"]:
+            model_id = record.get("id")
+            if not model_id:
+                continue
+            info = self._record_to_info(record, provider)
+            if info:
+                listings[model_id] = info
+        return listings
+
     def refresh_provider_cache(self, provider: str) -> bool:
         if not self._ensure_provider_state(provider):
             return False

cecli_dev-1.5.0rc5/cecli/helpers/onboarding/__init__.py

@@ -0,0 +1,99 @@
+"""Inline onboarding wizard for cecli.
+
+When a user has no default model configured and no API keys are detected,
+:func:`run_onboarding` launches a full-screen Textual picker that lets them:
+
+    #. pick a model provider (OpenAI, Anthropic, or any provider from ``providers.json``)
+    #. enter the provider's ``_API_KEY`` environment variable(s)
+    #. pick a default model
+
+The entered keys are persisted to ``~/.cecli/.env`` and the chosen default
+model is persisted to ``~/.cecli/conf.yml`` so future sessions load them
+automatically.
+"""
+
+import sys
+from pathlib import Path
+from typing import Dict, List, Optional
+
+from .providers import iter_providers
+
+
+def _env_file() -> Path:
+    return Path.home() / ".cecli" / ".env"
+
+
+def _conf_file() -> Path:
+    return Path.home() / ".cecli" / "conf.yml"
+
+
+def _persist_api_keys(api_keys: Optional[Dict[str, str]]) -> None:
+    if not api_keys:
+        return
+
+    import dotenv
+
+    env_file = _env_file()
+    env_file.parent.mkdir(parents=True, exist_ok=True)
+    for name, value in api_keys.items():
+        dotenv.set_key(str(env_file), name, value, quote_mode="always")
+
+
+def _persist_default_model(model: str) -> None:
+    import yaml
+
+    conf_file = _conf_file()
+    conf_file.parent.mkdir(parents=True, exist_ok=True)
+
+    config = {}
+    if conf_file.exists():
+        try:
+            with conf_file.open("r", encoding="utf-8") as f:
+                content = yaml.safe_load(f)
+                if isinstance(content, dict):
+                    config = content
+        except Exception:
+            config = {}
+
+    config["model"] = model
+    config["agent"] = True
+
+    with conf_file.open("w", encoding="utf-8") as f:
+        yaml.safe_dump(config, f, sort_keys=False, default_flow_style=False)
+
+
+async def run_onboarding(io) -> Optional[str]:
+    """Run the onboarding wizard and return the chosen default model name.
+
+    Returns ``None`` when the user cancels or the wizard cannot be launched
+    (for example when ``textual`` is not installed).
+    """
+    try:
+        from .app import OnboardingApp
+    except ImportError as e:
+        io.tool_error("Onboarding requires the 'textual' package.")
+        io.tool_output(f"Install with: pip install cecli-dev[tui] ({e})")
+        return None
+
+    if sys.stdin is None or not sys.stdin.isatty():
+        return None
+
+    providers: List[Dict] = iter_providers()
+    app = OnboardingApp(providers)
+
+    try:
+        result = await app.run_async()
+    except Exception as e:
+        io.tool_error(f"Onboarding failed: {e}")
+        return None
+
+    if not result:
+        return None
+
+    try:
+        _persist_api_keys(result.get("api_keys") or {})
+        _persist_default_model(result["model"])
+    except Exception as e:
+        io.tool_warning(f"Failed to persist onboarding settings: {e}")
+
+    return result["model"]

cecli_dev-1.5.0rc5/cecli/helpers/onboarding/app.py

@@ -0,0 +1,362 @@
+"""Textual onboarding wizard for cecli.
+
+Runs an inline full-screen picker that lets a user choose a model provider,
+enter the relevant API key(s), and pick a default model. The collected values
+are returned to :func:`cecli.helpers.onboarding.run_onboarding` for
+persistence to ``~/.cecli/.env`` and ``~/.cecli/conf.yml``.
+"""
+
+import os
+from functools import lru_cache
+from typing import Dict, List, Optional
+
+import textual.strip
+from rich.color import ColorSystem
+from rich.style import Style
+from textual.app import App, ComposeResult
+from textual.binding import Binding
+from textual.containers import Vertical
+from textual.message import Message
+from textual.screen import Screen
+from textual.widgets import Footer, Input, OptionList, Static
+from textual.widgets.option_list import Option
+
+from .providers import get_models_for_provider, provider_display, provider_needs_key
+
+# Sentinel returned by a screen to signal "go back a step" rather than cancel.
+_BACK = object()
+
+
+class FilterableList(Vertical):
+    """A search-as-you-type input paired with an option list."""
+
+    BINDINGS = [
+        Binding("up", "move_up", "Up", show=False),
+        Binding("down", "move_down", "Down", show=False),
+    ]
+
+    class Selected(Message):
+        """Posted when the user selects an option."""
+
+        def __init__(self, value) -> None:
+            super().__init__()
+            self.value = value
+
+    def __init__(
+        self, values: List, label_fn=None, prompt: str = "Search...", id: Optional[str] = None
+    ):
+        super().__init__(id=id)
+        self.values = list(values)
+        self.label_fn = label_fn or (lambda v: str(v))
+        self._visible = list(self.values)
+        self.prompt = prompt
+
+    def compose(self) -> ComposeResult:
+        yield Input(placeholder=self.prompt, id="filter")
+        yield OptionList(id="options")
+
+    def on_mount(self) -> None:
+        self._render_options()
+        self.query_one("#filter", Input).focus()
+
+    def _render_options(self) -> None:
+        options = self.query_one("#options", OptionList)
+        options.clear_options()
+        for value in self._visible:
+            options.add_option(Option(self.label_fn(value)))
+        if self._visible:
+            options.highlighted = 0
+
+    def on_input_changed(self, event) -> None:
+        query = event.value.strip().lower()
+        if query:
+            self._visible = [v for v in self.values if query in self.label_fn(v).lower()]
+        else:
+            self._visible = list(self.values)
+        self._render_options()
+
+    def on_input_submitted(self, event) -> None:
+        self._select_highlighted()
+
+    def _select_highlighted(self) -> None:
+        options = self.query_one("#options", OptionList)
+        index = options.highlighted
+        if index is not None and 0 <= index < len(self._visible):
+            self.post_message(self.Selected(self._visible[index]))
+
+    def action_move_up(self) -> None:
+        self.query_one("#options", OptionList).action_cursor_up()
+
+    def action_move_down(self) -> None:
+        self.query_one("#options", OptionList).action_cursor_down()
+
+    def on_option_list_option_selected(self, event) -> None:
+        index = event.option_index
+        if index is not None and 0 <= index < len(self._visible):
+            self.post_message(self.Selected(self._visible[index]))
+
+
+class ProviderScreen(Screen):
+    """First step: pick a provider."""
+
+    def __init__(self, providers: List[Dict]) -> None:
+        super().__init__()
+        self.providers = providers
+
+    def compose(self) -> ComposeResult:
+        yield Static("Pick a model provider")
+        yield FilterableList(
+            self.providers, label_fn=provider_display, prompt="Search providers...", id="providers"
+        )
+        yield Footer()
+
+    def on_filterable_list_selected(self, event) -> None:
+        self.dismiss(event.value)
+
+
+class ApiKeyScreen(Screen):
+    """Second step: enter the provider's API key(s)."""
+
+    BINDINGS = [Binding("escape", "back", "Back")]
+
+    def __init__(
+        self, provider: Dict, env_vars: List[str], collected: Optional[Dict] = None
+    ) -> None:
+        super().__init__()
+        self.provider = provider
+        self.env_vars = list(env_vars)
+        self.index = 0
+        self.collected = dict(collected or {})
+
+    def action_back(self) -> None:
+        self.dismiss(_BACK)
+
+    def compose(self) -> ComposeResult:
+        yield Static(id="prompt")
+        yield Input(password=True, placeholder="", id="key")
+        yield Static("Press Enter to continue", id="hint")
+        yield Footer()
+
+    def on_mount(self) -> None:
+        self._refresh()
+
+    def _refresh(self) -> None:
+        env_var = self.env_vars[self.index]
+        self.query_one("#prompt", Static).update(f"Enter your {env_var}")
+        self.query_one("#key", Input).placeholder = env_var
+        self.query_one("#key", Input).focus()
+
+    def on_input_submitted(self, event) -> None:
+        value = event.value.strip()
+        if not value:
+            self.query_one("#key", Input).focus()
+            return
+
+        self.collected[self.env_vars[self.index]] = value
+        self.index += 1
+        if self.index < len(self.env_vars):
+            self.query_one("#key", Input).value = ""
+            self._refresh()
+        else:
+            self.dismiss(self.collected)
+
+
+class LoadingScreen(Screen):
+    """Transient screen shown while provider models are fetched."""
+
+    def compose(self) -> ComposeResult:
+        yield Static("Fetching available models...")
+        yield Footer()
+
+
+class ModelScreen(Screen):
+    """Model picker (when provider discovery returns models)."""
+
+    def __init__(self, models: List[str]) -> None:
+        super().__init__()
+        self.models = models
+
+    def compose(self) -> ComposeResult:
+        yield Static("Pick a default model")
+        yield FilterableList(self.models, prompt="Search models...", id="models")
+        yield Footer()
+
+    def on_filterable_list_selected(self, event) -> None:
+        self.dismiss(event.value)
+
+
+class ModelManualScreen(Screen):
+    """Manual model entry (when provider discovery returns no models)."""
+
+    def __init__(self, provider: Dict) -> None:
+        super().__init__()
+        self.provider = provider
+
+    def compose(self) -> ComposeResult:
+        yield Static(
+            f"No models found for '{self.provider['display_name']}'. Enter a model name manually:"
+        )
+        yield Input(placeholder="model name", id="model")
+        yield Footer()
+
+    def on_input_submitted(self, event) -> None:
+        value = event.value.strip()
+        if value:
+            self.dismiss(value)
+
+
+class OnboardingApp(App):
+    """Inline onboarding wizard."""
+
+    CSS = """
+    FilterableList {
+        height: 1fr;
+        padding: 0 1;
+    }
+    FilterableList OptionList {
+        height: 1fr;
+        border: round #00ff87 50%;
+        scrollbar-size-vertical: 1;
+        scrollbar-size-horizontal: 1;
+    }
+    FilterableList OptionList > .option-list--option-highlighted {
+        color: #00b365;
+        background: transparent;
+        text-style: bold;
+    }
+    FilterableList OptionList:focus > .option-list--option-highlighted {
+        color: #00b365;
+        background: transparent;
+        text-style: bold;
+    }
+    Input {
+        border: round #00ff87 50%;
+        margin: 0;
+    }
+    Static {
+        margin: 0 1;
+    }
+    """
+
+    BINDINGS = [
+        Binding("escape", "cancel", "Cancel"),
+        Binding("ctrl+c", "cancel", "Cancel"),
+    ]
+
+    def __init__(self, providers: List[Dict]) -> None:
+        super().__init__()
+        self.providers = providers
+        self.provider: Optional[Dict] = None
+        self.api_keys: Dict[str, str] = {}
+        self.result = None
+
+    def on_mount(self) -> None:
+        self.push_screen(ProviderScreen(self.providers), self._on_provider)
+
+    def action_cancel(self) -> None:
+        self.result = None
+        self.exit(None)
+
+    def _on_provider(self, provider) -> None:
+        if provider is None:
+            self.exit(None)
+            return
+        self.provider = provider
+        env_vars = provider.get("api_key_env") or []
+        if (
+            provider_needs_key(provider)
+            and env_vars
+            and not all(os.environ.get(v) for v in env_vars)
+        ):
+            self.push_screen(ApiKeyScreen(provider, env_vars), self._on_api_keys)
+        else:
+            present = {v: os.environ[v] for v in env_vars if os.environ.get(v)}
+            self._on_api_keys(present)
+
+    def _on_api_keys(self, keys) -> None:
+        if keys is _BACK:
+            self._back_to_provider()
+            return
+        if keys is None:
+            self.exit(None)
+            return
+        self.api_keys = keys or {}
+        for name, value in self.api_keys.items():
+            os.environ[name] = value
+        self._fetch_models()
+
+    def _back_to_provider(self) -> None:
+        self.provider = None
+        self.api_keys = {}
+        self.push_screen(ProviderScreen(self.providers), self._on_provider)
+
+    def _fetch_models(self) -> None:
+        slug = self.provider["slug"]
+        self.push_screen(LoadingScreen())
+
+        def worker() -> None:
+            try:
+                models = get_models_for_provider(slug)
+            except Exception:
+                models = []
+            self.call_from_thread(self._finish_fetch, models)
+
+        self.run_worker(worker, thread=True)
+
+    def _finish_fetch(self, models) -> None:
+        if self.screen is not None:
+            self.pop_screen()
+        self._on_models(models)
+
+    def _on_models(self, models) -> None:
+        if not models:
+            self.push_screen(ModelManualScreen(self.provider), self._on_model)
+        else:
+            self.push_screen(ModelScreen(models), self._on_model)
+
+    def _on_model(self, model) -> None:
+        if model is None:
+            self.result = None
+            self.exit(None)
+            return
+        self.result = {
+            "provider": self.provider["slug"],
+            "api_keys": self.api_keys,
+            "model": model,
+        }
+        self.exit(self.result)
+
+
+def patch_textual_strip_render_with_cache():
+    """Monkey-patch Textual's ANSI renderer to ignore background colors.
+
+    Applied permanently at import time so the inline onboarding wizard keeps the
+    terminal's own background rather than cecli's dark theme painting over it.
+    """
+
+    def modified_render_ansi(cls, style: Style, color_system: ColorSystem) -> str:
+        """Modified ANSI generator that ignores background colors."""
+        sgr: list[str]
+        if attributes := style._attributes & style._set_attributes:
+            _style_map = textual.strip.SGR_STYLES
+            sgr = [
+                _style_map[bit_offset]
+                for bit_offset in range(attributes.bit_length())
+                if attributes & (1 << bit_offset)
+            ]
+        else:
+            sgr = []
+
+        if (color := style._color) is not None:
+            sgr.extend(color.downgrade(color_system).get_ansi_codes())
+
+        # BACKGROUND OVERRIDE: Skip the bgcolor block entirely
+        ansi = style._ansi = ";".join(sgr)
+        return ansi
+
+    cached_version = lru_cache(maxsize=16384)(modified_render_ansi)
+    textual.strip.Strip.render_ansi = classmethod(cached_version)
+
+
+# Apply the no-background-color hack permanently for the onboarding wizard.
+patch_textual_strip_render_with_cache()

cecli_dev-1.5.0rc5/cecli/helpers/onboarding/providers.py

@@ -0,0 +1,149 @@
+"""Provider and model discovery for the onboarding wizard."""
+
+import importlib.resources as importlib_resources
+import json
+import os
+from typing import Dict, List
+
+# Providers that authenticate through mechanisms other than a simple _API_KEY
+# (e.g. GitHub Copilot tokens or AWS credentials), so onboarding should never
+# prompt for a key and instead jump straight to model selection.
+NO_KEY_SLUGS = {"github_copilot", "bedrock", "bedrock_mantle"}
+
+# Friendly display names for the default providers that are not covered by
+# providers.json.
+_PROVIDER_DISPLAY: Dict[str, str] = {
+    "openai": "OpenAI",
+    "anthropic": "Anthropic",
+    "deepseek": "DeepSeek",
+    "openrouter": "OpenRouter",
+    "gemini": "Google Gemini",
+    "github_copilot": "GitHub Copilot",
+    "meta": "Meta",
+}
+
+# Builtin providers used as a fallback if the llms config is unavailable.
+BUILTIN_PROVIDERS: List[Dict] = [
+    {"slug": "openai", "display_name": "OpenAI", "api_key_env": ["OPENAI_API_KEY"]},
+    {"slug": "anthropic", "display_name": "Anthropic", "api_key_env": ["ANTHROPIC_API_KEY"]},
+    {
+        "slug": "github_copilot",
+        "display_name": "GitHub Copilot",
+        "api_key_env": ["GITHUB_COPILOT_TOKEN"],
+    },
+]
+
+# The bundled metadata resources used for model discovery. The ext file is a
+# superset, so later entries win when both are merged.
+_METADATA_RESOURCES = ("model-metadata.json", "model-metadata.ext.json")
+
+
+def _provider_configs() -> Dict:
+    from cecli.helpers.model_providers import PROVIDER_CONFIGS
+
+    return PROVIDER_CONFIGS
+
+
+def _load_metadata() -> Dict:
+    """Merge the bundled model metadata resources into one ``{model: info}`` dict."""
+    data = {}
+    for name in _METADATA_RESOURCES:
+        try:
+            resource = importlib_resources.files("cecli.resources").joinpath(name)
+        except (FileNotFoundError, ModuleNotFoundError):
+            continue
+        try:
+            entries = json.loads(resource.read_text())
+        except (json.JSONDecodeError, OSError):
+            continue
+        if isinstance(entries, dict):
+            data.update(entries)
+    return data
+
+
+def _models_from_metadata(data: Dict, slug: str) -> List[str]:
+    """Return selectable model names for a provider from the metadata dict."""
+    models = []
+    for name, meta in data.items():
+        if not isinstance(meta, dict):
+            continue
+        provider = meta.get("litellm_provider") or ""
+        if provider == slug:
+            models.append(name if name.startswith(slug + "/") else f"{slug}/{name}")
+        elif name.startswith(slug + "/"):
+            models.append(name)
+    return models
+
+
+def iter_providers() -> List[Dict]:
+    """Return the list of providers selectable during onboarding."""
+    providers: Dict[str, Dict] = {}
+
+    # Default providers from the llms config (openai, anthropic, deepseek,
+    # openrouter, gemini, github_copilot, meta, chutes, opencode-*).
+    try:
+        from cecli.helpers.llms.config import PROVIDER_DEFAULTS
+    except ImportError:
+        PROVIDER_DEFAULTS = None
+
+    if PROVIDER_DEFAULTS:
+        for slug, cfg in PROVIDER_DEFAULTS.items():
+            key_env = cfg.get("api_key_env")
+            key_env = [key_env] if isinstance(key_env, str) and key_env else []
+            providers[slug] = {
+                "slug": slug,
+                "display_name": _PROVIDER_DISPLAY.get(slug) or slug,
+                "api_key_env": key_env,
+            }
+    else:
+        for entry in BUILTIN_PROVIDERS:
+            providers[entry["slug"]] = dict(entry)
+
+    # Custom providers from providers.json override the defaults where present.
+    for slug, cfg in _provider_configs().items():
+        providers[slug] = {
+            "slug": slug,
+            "display_name": cfg.get("display_name", slug),
+            "api_key_env": list(cfg.get("api_key_env", []) or []),
+        }
+
+    return list(providers.values())
+
+
+def provider_has_key(entry: Dict) -> bool:
+    """Return True if the provider already has a key in the environment."""
+    return any(os.environ.get(env_var) for env_var in entry.get("api_key_env") or [])
+
+
+def provider_needs_key(entry: Dict) -> bool:
+    """Return True if onboarding should prompt the user for an API key."""
+    return entry["slug"] not in NO_KEY_SLUGS
+
+
+def provider_display(entry: Dict) -> str:
+    """Return the display label for a provider entry."""
+    label = entry.get("display_name", entry["slug"])
+    if provider_has_key(entry):
+        return f"{label}  (key set)"
+    return label
+
+
+def get_models_for_provider(slug: str) -> List[str]:
+    """Return the selectable model names for a provider."""
+    models = _models_from_metadata(_load_metadata(), slug)
+    if models:
+        return sorted(set(models))
+
+    # Fall back to a live fetch for providers absent from the bundled metadata.
+    from cecli.models import model_info_manager
+
+    manager = model_info_manager.provider_manager
+    if manager.supports_provider(slug):
+        try:
+            manager.refresh_provider_cache(slug)
+        except Exception:
+            pass
+        content = manager.get_provider_models(slug)
+        if content:
+            return sorted(f"{slug}/{model_id}" for model_id in content)
+    return []