pairwit 0.0.2__tar.gz → 0.0.4__tar.gz

{pairwit-0.0.2 → pairwit-0.0.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: pairwit
-Version: 0.0.2
+Version: 0.0.4
 Summary: Consent-first coding agent for your terminal (Plan/Build, approvals, /schedule)
 Project-URL: Homepage, https://pairwit.dev
 Project-URL: Repository, https://github.com/pairwit/pairwit
@@ -35,6 +35,8 @@ pairwit
 
 Public alpha — APIs and UX may change. Feedback welcome.
 
+On first launch, Pairwit opens a guided provider setup (pick provider → API key → model → connection check). Keys go to `~/.pairwit/.env`. On Windows, if `pairwit` is not on PATH, use `py -m pairwit`.
+
 Editable install from a checkout:
 
 ```bash

{pairwit-0.0.2 → pairwit-0.0.4}/README.md

@@ -9,6 +9,8 @@ pairwit
 
 Public alpha — APIs and UX may change. Feedback welcome.
 
+On first launch, Pairwit opens a guided provider setup (pick provider → API key → model → connection check). Keys go to `~/.pairwit/.env`. On Windows, if `pairwit` is not on PATH, use `py -m pairwit`.
+
 Editable install from a checkout:
 
 ```bash

{pairwit-0.0.2 → pairwit-0.0.4}/pairwit/__init__.py

@@ -2,7 +2,7 @@
 
 from __future__ import annotations
 
-__version__ = "0.0.2"
+__version__ = "0.0.4"
 
 
 def main() -> None:

{pairwit-0.0.2 → pairwit-0.0.4}/pairwit/ai/clients.py

@@ -112,6 +112,123 @@ def _build_anthropic_client() -> Any:
     return _anthropic_mod.Anthropic(api_key=key)
 
 
+PROVIDER_KEY_HINTS: dict[str, str] = {
+    "moonshot": "Get a key: https://platform.moonshot.ai",
+    "openai": "Get a key: https://platform.openai.com/api-keys",
+    "anthropic": "Get a key: https://console.anthropic.com/settings/keys",
+    "openrouter": "Get a key: https://openrouter.ai/keys",
+    "deepseek": "Get a key: https://platform.deepseek.com/api_keys",
+    "custom": "Use any OpenAI-compatible base URL + API key.",
+    "ollama": "Install Ollama and pull a model: https://ollama.com",
+}
+
+
+def _smoke_test_provider(
+    provider_id: str,
+    model: str,
+    *,
+    api_key: str | None = None,
+    base_url: str | None = None,
+    timeout_s: float = 12.0,
+) -> str | None:
+    """Return None on success, or a short error message if the provider cannot chat.
+
+    Optional api_key / base_url override process env so the wizard can verify
+    before writing ~/.pairwit/.env.
+    """
+    from pairwit.ai.catalog import _discover_ollama_models
+
+    provider_id = (provider_id or "").strip().lower()
+    model = (model or "").strip()
+    if provider_id not in PROVIDERS:
+        return f"Unknown provider: {provider_id}"
+    if not model:
+        return "Pick a model to continue."
+
+    if provider_id == "ollama":
+        models = _discover_ollama_models()
+        if not models:
+            return f"Ollama unreachable at {_ollama_host()} — start the daemon and pull a model."
+        ids = {m.id for m in models}
+        # Allow tag-less matches (llama3.2 vs llama3.2:latest)
+        if model not in ids and not any(mid.startswith(f"{model}:") or model.startswith(f"{mid}:") for mid in ids):
+            # Still OK if daemon is up — default model may not be pulled yet
+            return (
+                f"Ollama is up but model `{model}` was not found. "
+                f"Pull it (`ollama pull {model}`) or pick another model."
+            )
+        return None
+
+    if provider_id == "anthropic":
+        if _anthropic_mod is None:
+            return "Install the anthropic package: pip install anthropic"
+        if api_key is not None:
+            key = api_key.strip()
+        else:
+            key = (_provider_api_key("anthropic") or "").strip()
+        if not key:
+            return "ANTHROPIC_API_KEY is required."
+        try:
+            client = _anthropic_mod.Anthropic(api_key=key, timeout=timeout_s)
+            client.messages.create(
+                model=model,
+                max_tokens=1,
+                messages=[{"role": "user", "content": "ping"}],
+            )
+        except Exception as exc:  # noqa: BLE001 — surface provider error to wizard
+            return _smoke_error_text(exc)
+        return None
+
+    # OpenAI-compatible providers
+    if api_key is not None:
+        key = api_key.strip()
+    else:
+        key = (_provider_api_key(provider_id) or "").strip()
+    if not key:
+        env_name = PROVIDERS[provider_id].api_key_env or "API key"
+        return f"{env_name} is required."
+
+    if provider_id == "custom":
+        if base_url is not None:
+            resolved_base = base_url.strip().rstrip("/")
+        else:
+            resolved_base = (_env_get("PAIRWIT_BASE_URL") or "").rstrip("/")
+        if not resolved_base:
+            return "PAIRWIT_BASE_URL is required for custom providers."
+    else:
+        resolved_base = _openai_compat_base_url(provider_id)
+
+    headers: dict[str, str] | None = None
+    if provider_id == "openrouter":
+        headers = {
+            "HTTP-Referer": "https://github.com/pairwit/pairwit",
+            "X-Title": "Pairwit",
+        }
+    try:
+        client = OpenAI(
+            api_key=key or "ollama",
+            base_url=resolved_base,
+            default_headers=headers,
+            timeout=timeout_s,
+        )
+        client.chat.completions.create(
+            model=model,
+            messages=[{"role": "user", "content": "ping"}],
+            max_tokens=1,
+        )
+    except Exception as exc:  # noqa: BLE001
+        return _smoke_error_text(exc)
+    return None
+
+
+def _smoke_error_text(exc: BaseException) -> str:
+    text = str(exc).strip() or exc.__class__.__name__
+    # Keep the modal readable
+    if len(text) > 180:
+        text = text[:177] + "…"
+    return text
+
+
 def _openai_tools_to_anthropic(tools: list[dict]) -> list[dict]:
     converted: list[dict] = []
     for tool in tools:

{pairwit-0.0.2 → pairwit-0.0.4}/pairwit/ai/providers.py

@@ -22,6 +22,7 @@ from pairwit.ai.catalog import (
     _set_active_pricing,
 )
 from pairwit.ai.clients import (
+    PROVIDER_KEY_HINTS,
     _anthropic_mod,
     _build_anthropic_client,
     _build_openai_client,
@@ -33,6 +34,7 @@ from pairwit.ai.clients import (
     _openai_tools_to_anthropic,
     _provider_api_key,
     _provider_missing_key_message,
+    _smoke_test_provider,
 )
 from pairwit.ai.types import ModelInfo, ProviderSpec
 
@@ -44,6 +46,7 @@ __all__ = [
     "MODEL_INPUT_USD_PER_M",
     "MODEL_OUTPUT_USD_PER_M",
     "PROVIDER",
+    "PROVIDER_KEY_HINTS",
     "PROVIDER_ORDER",
     "PROVIDERS",
     "ModelInfo",
@@ -67,4 +70,5 @@ __all__ = [
     "_provider_missing_key_message",
     "_provider_spec",
     "_set_active_pricing",
+    "_smoke_test_provider",
 ]

{pairwit-0.0.2 → pairwit-0.0.4}/pairwit/tui/app.py

@@ -164,6 +164,7 @@ from pairwit.tui.widgets import (
     Prompt,
     PromptModal,
     ProviderPickerScreen,
+    ProviderSetupScreen,
     Response,
     SchedulePane,
     SessionStatsBar,
@@ -523,7 +524,9 @@ class PairwitApp(App):
         self._openai_client: OpenAI | None = None
         self._anthropic_client: Any | None = None
         self._provider_note: str | None = None
-        self.rebuild_llm()
+        self._needs_provider_setup = bool(_provider_missing_key_message(self._provider))
+        if not self._needs_provider_setup:
+            self.rebuild_llm()
         self._refresh_mode_subtitle()
 
     def rebuild_llm(self) -> None:
@@ -710,6 +713,8 @@ class PairwitApp(App):
             self.call_after_refresh(self._show_startup_note, self._provider_note)
         if self._mcp_note:
             self.call_after_refresh(self._show_startup_note, self._mcp_note)
+        if self._needs_provider_setup:
+            self.call_after_refresh(self._launch_provider_setup)
         if self._pending_replay_banner:
             banner = self._pending_replay_banner
             self._pending_replay_banner = None
@@ -722,6 +727,46 @@ class PairwitApp(App):
     def _show_startup_note(self, text: str) -> None:
         self.run_worker(self._show_system_note(text))
 
+    def _launch_provider_setup(self) -> None:
+        self._run_provider_setup()
+
+    @work(exclusive=True)
+    async def _run_provider_setup(self) -> None:
+        """Block first-run until a usable provider is configured."""
+        reason = _provider_missing_key_message(self._provider)
+        while self._needs_provider_setup:
+            result = await self.push_screen_wait(
+                ProviderSetupScreen(
+                    current_provider=self._provider,
+                    reason=(reason or "").replace("❌  ", "").split("\n", 1)[0] or None,
+                )
+            )
+            if result is None:
+                self.exit(return_code=1)
+                return
+            self._provider = result["provider"]
+            self._model = result.get("model") or PROVIDERS[self._provider].default_model
+            try:
+                self.rebuild_llm()
+            except Exception as exc:
+                reason = str(exc)
+                await self._show_system_note(f"Could not start provider: {exc}")
+                continue
+            if _provider_missing_key_message(self._provider):
+                reason = _provider_missing_key_message(self._provider)
+                continue
+            self._needs_provider_setup = False
+            self._refresh_mode_subtitle()
+            env_path = result.get("env_path", "~/.pairwit/.env")
+            note = (
+                f"Connected · `{self._model}` · `{self._provider}`.\n"
+                f"Saved to `{env_path}`. Change later with /provider."
+            )
+            if self._provider_note:
+                note = f"{note}\n{self._provider_note}"
+            await self._show_system_note(note)
+            return
+
     def _startup_replay(self, banner: str) -> None:
         self.run_worker(self._replay_session_ui(banner=banner))
 
@@ -1601,8 +1646,17 @@ class PairwitApp(App):
             return
         fatal = _provider_missing_key_message(picked)
         if fatal:
-            await self._show_system_note(fatal.replace("❌  ", "").replace("\n", " "))
-            return
+            setup = await self.push_screen_wait(
+                ProviderSetupScreen(
+                    current_provider=self._provider,
+                    initial_provider=picked,
+                    reason=f"Configure {picked} before switching.",
+                )
+            )
+            if not setup:
+                return
+            picked = setup["provider"]
+            self._model = setup.get("model") or PROVIDERS[picked].default_model
         prev_provider = self._provider
         prev_model = self._model
         self._provider = picked
@@ -1615,11 +1669,13 @@ class PairwitApp(App):
             self._provider = prev_provider
             self._model = prev_model
             try:
-                self.rebuild_llm()
+                if not self._needs_provider_setup:
+                    self.rebuild_llm()
             except Exception:
                 pass
             await self._show_system_note(f"Could not switch provider: {exc}")
             return
+        self._needs_provider_setup = False
         self._refresh_mode_subtitle()
         note = f"Provider set to `{self._provider}` · model `{self._model}`."
         if self._provider_note:
@@ -1710,6 +1766,13 @@ class PairwitApp(App):
 
     @on(Input.Submitted, "#prompt-input")
     async def on_input(self, event: Input.Submitted) -> None:
+        if self._needs_provider_setup:
+            event.input.clear()
+            await self._show_system_note(
+                "Finish provider setup first (or press Esc in the setup dialog to quit)."
+            )
+            self._launch_provider_setup()
+            return
         raw = event.value.strip()
         if raw.startswith("/"):
             event.input.clear()
@@ -2294,12 +2357,6 @@ class PairwitApp(App):
 
 def agent_loop() -> None:
     resume = "--resume" in sys.argv[1:]
-    provider = (_env_get("PAIRWIT_PROVIDER") or DEFAULT_PROVIDER).strip().lower()
-    if provider not in PROVIDERS:
-        provider = DEFAULT_PROVIDER
-    fatal = _provider_missing_key_message(provider)
-    if fatal:
-        raise SystemExit(fatal)
     PairwitApp(resume=resume).run()
 
 

{pairwit-0.0.2 → pairwit-0.0.4}/pairwit/tui/widgets/__init__.py

@@ -42,6 +42,7 @@ from pairwit.tui.widgets.modals import (
     ModelPickerScreen,
     PromptModal,
     ProviderPickerScreen,
+    ProviderSetupScreen,
     SessionsPickerScreen,
     ToolApprovalScreen,
     TreeContextMenu,
@@ -88,6 +89,7 @@ __all__ = [
     "Prompt",
     "PromptModal",
     "ProviderPickerScreen",
+    "ProviderSetupScreen",
     "Response",
     "SCHEDULE_DEFAULT_WIDTH",
     "SCHEDULE_MIN_WIDTH",

{pairwit-0.0.2 → pairwit-0.0.4}/pairwit/tui/widgets/modals.py

@@ -14,11 +14,15 @@ from textual.widgets import Input, OptionList, Static
 from textual.widgets._option_list import Option
 
 from pairwit.ai.providers import (
+    PROVIDER_KEY_HINTS,
     PROVIDER_ORDER,
     PROVIDERS,
     ModelInfo,
     _discover_ollama_models,
+    _models_for_provider,
+    _ollama_host,
     _provider_missing_key_message,
+    _smoke_test_provider,
 )
 from pairwit.core import MENTION_PICKER_MAX, MODEL
 from pairwit.tools.approval import (
@@ -761,3 +765,446 @@ class TreeContextMenu(ModalScreen[Optional[str]]):
     def on_option_selected(self, event: OptionList.OptionSelected) -> None:
         event.stop()
         self.dismiss(event.option_id)
+
+
+class ProviderSetupScreen(ModalScreen[dict[str, str] | None]):
+    """Hermes-style first-run wizard: welcome → provider → key → model → verify."""
+
+    BINDINGS = [
+        Binding("escape", "cancel", "Back", show=False),
+    ]
+
+    STEPS = ("welcome", "provider", "key", "model", "verify")
+
+    DEFAULT_CSS = f"""
+    ProviderSetupScreen {{
+        align: center middle;
+        background: #091e42 78%;
+    }}
+
+    ProviderSetupScreen #setup-modal-box {{
+        width: 74;
+        height: auto;
+        max-height: 28;
+        border: tall {KIMI_BLUE};
+        background: {KIMI_SURFACE};
+        padding: 1 2;
+    }}
+
+    ProviderSetupScreen #setup-title {{
+        color: {KIMI_TEXT};
+        text-style: bold;
+        padding: 0 0 0 0;
+    }}
+
+    ProviderSetupScreen #setup-step {{
+        color: {KIMI_MUTED};
+        padding: 0 0 1 0;
+    }}
+
+    ProviderSetupScreen #setup-hint {{
+        color: {KIMI_MUTED};
+        padding: 0 0 1 0;
+    }}
+
+    ProviderSetupScreen #setup-error {{
+        color: {KIMI_ORANGE};
+        padding: 0 0 1 0;
+    }}
+
+    ProviderSetupScreen #setup-status {{
+        color: {KIMI_TEXT};
+        padding: 0 0 1 0;
+    }}
+
+    ProviderSetupScreen OptionList {{
+        height: auto;
+        max-height: 12;
+        border: solid {KIMI_BORDER};
+    }}
+
+    ProviderSetupScreen .option-list--option-highlighted {{
+        background: {KIMI_BLUE} 18%;
+        color: {KIMI_TEXT};
+    }}
+
+    ProviderSetupScreen Input {{
+        border: solid {KIMI_BORDER};
+        background: {KIMI_SURFACE_ALT};
+        color: {KIMI_TEXT};
+        margin: 0 0 1 0;
+    }}
+
+    ProviderSetupScreen #setup-footer {{
+        color: {KIMI_MUTED};
+        padding: 1 0 0 0;
+    }}
+    """
+
+    def __init__(
+        self,
+        *,
+        current_provider: str = "moonshot",
+        reason: str | None = None,
+        initial_provider: str | None = None,
+    ) -> None:
+        super().__init__()
+        self._current_provider = current_provider
+        self._reason = reason
+        self._providers = [PROVIDERS[pid] for pid in PROVIDER_ORDER if pid in PROVIDERS]
+        self._step = "welcome"
+        self._selected_id = initial_provider if initial_provider in PROVIDERS else None
+        self._api_key = ""
+        self._base_url = ""
+        self._model = (
+            PROVIDERS[self._selected_id].default_model
+            if self._selected_id
+            else PROVIDERS.get(current_provider, PROVIDERS["moonshot"]).default_model
+        )
+        self._verifying = False
+        self._verify_error = ""
+
+    def compose(self) -> ComposeResult:
+        with Vertical(id="setup-modal-box"):
+            yield Static("Welcome to Pairwit", id="setup-title")
+            yield Static("Step 1 of 5", id="setup-step")
+            yield Static("", id="setup-hint")
+            yield Static("", id="setup-error")
+            yield Static("", id="setup-status")
+            yield OptionList(id="setup-list")
+            yield Static("", id="setup-key-label")
+            yield Input(placeholder="API key", password=True, id="setup-api-key")
+            yield Static("", id="setup-base-label")
+            yield Input(placeholder="https://…/v1", id="setup-base-url")
+            yield Static("Enter · continue   Esc · back / quit", id="setup-footer")
+
+    def on_mount(self) -> None:
+        if self._selected_id:
+            # Jump into credentials (or model for ollama) when opened from /provider.
+            if self._selected_id == "ollama":
+                self._show_step("model")
+            else:
+                self._show_step("key")
+            return
+        self._show_step("welcome")
+
+    def _set_error(self, message: str) -> None:
+        self.query_one("#setup-error", Static).update(message)
+
+    def _set_status(self, message: str) -> None:
+        self.query_one("#setup-status", Static).update(message)
+
+    def _hide_inputs(self) -> None:
+        self.query_one("#setup-key-label", Static).display = False
+        self.query_one("#setup-api-key", Input).display = False
+        self.query_one("#setup-base-label", Static).display = False
+        self.query_one("#setup-base-url", Input).display = False
+
+    def _step_index(self) -> int:
+        try:
+            return self.STEPS.index(self._step) + 1
+        except ValueError:
+            return 1
+
+    def _show_step(self, step: str) -> None:
+        self._step = step
+        self._set_error("")
+        self._set_status("")
+        self._hide_inputs()
+        title = self.query_one("#setup-title", Static)
+        step_label = self.query_one("#setup-step", Static)
+        hint = self.query_one("#setup-hint", Static)
+        option_list = self.query_one("#setup-list", OptionList)
+        footer = self.query_one("#setup-footer", Static)
+        step_label.update(f"Step {self._step_index()} of {len(self.STEPS)}")
+        option_list.display = True
+        option_list.clear_options()
+
+        if step == "welcome":
+            title.update("Welcome to Pairwit")
+            body = (
+                "Pairwit needs one AI provider before it can chat.\n"
+                "• Keys are saved locally to ~/.pairwit/.env\n"
+                "• Change later anytime with /provider\n"
+                "• Approvals stay on by default"
+            )
+            if self._reason:
+                body = f"{self._reason.strip()}\n\n{body}"
+            hint.update(body)
+            option_list.add_options([Option("Continue — choose a provider", id="act-continue")])
+            footer.update("Enter · continue   Esc · quit")
+            option_list.focus()
+            return
+
+        if step == "provider":
+            title.update("Choose a provider")
+            hint.update("Moonshot is the recommended path. Ollama needs no API key.")
+            options: list[Option] = []
+            for index, spec in enumerate(self._providers):
+                if spec.id == "moonshot":
+                    label = f"{spec.label} (recommended) · {spec.api_key_env}"
+                elif spec.id == "ollama":
+                    label = f"{spec.label} · local, no API key"
+                elif spec.id == "custom":
+                    label = f"{spec.label} · key + base URL"
+                else:
+                    label = f"{spec.label} · {spec.api_key_env}"
+                if spec.id == self._current_provider:
+                    label = f"{label} ← current"
+                options.append(Option(label, id=f"prov-{index}"))
+            option_list.add_options(options)
+            footer.update("Enter · select   Esc · back")
+            option_list.focus()
+            return
+
+        if step == "key":
+            assert self._selected_id
+            spec = PROVIDERS[self._selected_id]
+            title.update(f"Add your {spec.label} key")
+            hint_line = PROVIDER_KEY_HINTS.get(spec.id, "")
+            hint.update(
+                f"Paste {spec.api_key_env} below. {hint_line}".strip()
+            )
+            option_list.display = False
+            key_label = self.query_one("#setup-key-label", Static)
+            key_input = self.query_one("#setup-api-key", Input)
+            key_label.display = True
+            key_input.display = True
+            key_label.update(spec.api_key_env or "API key")
+            key_input.value = self._api_key
+            key_input.placeholder = spec.api_key_env or "API key"
+            if spec.id == "custom":
+                base_label = self.query_one("#setup-base-label", Static)
+                base_input = self.query_one("#setup-base-url", Input)
+                base_label.display = True
+                base_input.display = True
+                base_label.update("PAIRWIT_BASE_URL (OpenAI-compatible)")
+                base_input.value = self._base_url
+                base_input.focus()
+            else:
+                key_input.focus()
+            footer.update("Enter · continue   Esc · back")
+            return
+
+        if step == "model":
+            assert self._selected_id
+            spec = PROVIDERS[self._selected_id]
+            if not self._model:
+                self._model = spec.default_model
+            title.update("Confirm model")
+            hint.update(
+                f"Default for {spec.label} is `{spec.default_model}`. "
+                "Accept it, or pick another."
+            )
+            models = _models_for_provider(self._selected_id)
+            options = [
+                Option(
+                    f"Accept default · {spec.default_model}",
+                    id="model-default",
+                )
+            ]
+            for index, info in enumerate(models[:12]):
+                mark = " ✓" if info.id == self._model else ""
+                options.append(
+                    Option(f"{info.label} ({info.id}){mark}", id=f"model-{index}")
+                )
+            option_list.add_options(options)
+            footer.update("Enter · select   Esc · back")
+            option_list.focus()
+            return
+
+        if step == "verify":
+            assert self._selected_id
+            title.update("Verify connection")
+            hint.update(
+                f"Testing `{self._model}` on {PROVIDERS[self._selected_id].label}…"
+            )
+            option_list.display = False
+            footer.update("Please wait…")
+            self._start_verify()
+            return
+
+    def _start_verify(self) -> None:
+        if self._verifying:
+            return
+        self._verifying = True
+        self._set_status("Checking provider…")
+        self._set_error("")
+        self.run_worker(self._verify_worker, thread=True)
+
+    def _verify_worker(self) -> None:
+        provider_id = self._selected_id or ""
+        error = _smoke_test_provider(
+            provider_id,
+            self._model,
+            api_key=self._api_key or None,
+            base_url=self._base_url or None,
+        )
+        self.app.call_from_thread(self._on_verify_done, error)
+
+    def _on_verify_done(self, error: str | None) -> None:
+        self._verifying = False
+        if error:
+            self._verify_error = error
+            self._set_status("")
+            self._set_error(error)
+            option_list = self.query_one("#setup-list", OptionList)
+            option_list.display = True
+            option_list.clear_options()
+            options = [
+                Option("Retry connection test", id="act-retry"),
+            ]
+            if self._selected_id != "ollama":
+                options.append(Option("Change API key", id="act-change-key"))
+            options.append(Option("Choose another provider", id="act-change-provider"))
+            option_list.add_options(options)
+            self.query_one("#setup-footer", Static).update("Enter · choose   Esc · back")
+            option_list.focus()
+            return
+        self._finish_success()
+
+    def _finish_success(self) -> None:
+        from pairwit.util.env import upsert_pairwit_env
+
+        provider_id = self._selected_id
+        if not provider_id:
+            self._set_error("No provider selected.")
+            return
+        spec = PROVIDERS[provider_id]
+        values: dict[str, str] = {
+            "PAIRWIT_PROVIDER": provider_id,
+            "PAIRWIT_MODEL": self._model or spec.default_model,
+        }
+        if provider_id != "ollama" and spec.api_key_env and self._api_key:
+            values[spec.api_key_env] = self._api_key
+        if provider_id == "custom" and self._base_url:
+            values["PAIRWIT_BASE_URL"] = self._base_url.rstrip("/")
+        path = upsert_pairwit_env(values)
+        self._set_status(f"Connected · {self._model} · {spec.label}")
+        self.dismiss(
+            {
+                "provider": provider_id,
+                "model": self._model or spec.default_model,
+                "env_path": str(path),
+            }
+        )
+
+    def _advance_from_key(self) -> None:
+        provider_id = self._selected_id
+        if not provider_id:
+            self._set_error("Pick a provider first.")
+            return
+        spec = PROVIDERS[provider_id]
+        key = self.query_one("#setup-api-key", Input).value.strip()
+        if not key:
+            self._set_error(f"Enter {spec.api_key_env} to continue.")
+            self.query_one("#setup-api-key", Input).focus()
+            return
+        self._api_key = key
+        if provider_id == "custom":
+            base = self.query_one("#setup-base-url", Input).value.strip().rstrip("/")
+            if not base:
+                self._set_error("Enter PAIRWIT_BASE_URL (e.g. https://api.example.com/v1).")
+                self.query_one("#setup-base-url", Input).focus()
+                return
+            self._base_url = base
+        if provider_id == "anthropic":
+            from pairwit.ai.clients import _anthropic_mod
+
+            if _anthropic_mod is None:
+                self._set_error("Install the anthropic package: pip install anthropic")
+                return
+        self._model = spec.default_model
+        self._show_step("model")
+
+    def action_cancel(self) -> None:
+        if self._verifying:
+            return
+        if self._step == "welcome":
+            self.dismiss(None)
+            return
+        if self._step == "provider":
+            self._show_step("welcome")
+            return
+        if self._step == "key":
+            self._show_step("provider")
+            return
+        if self._step == "model":
+            if self._selected_id == "ollama":
+                self._show_step("provider")
+            else:
+                self._show_step("key")
+            return
+        if self._step == "verify":
+            self._show_step("model")
+            return
+        self.dismiss(None)
+
+    @on(OptionList.OptionSelected, "#setup-list")
+    def on_list_selected(self, event: OptionList.OptionSelected) -> None:
+        event.stop()
+        option_id = event.option_id or ""
+        if option_id == "act-continue":
+            self._show_step("provider")
+            return
+        if option_id == "act-retry":
+            self._show_step("verify")
+            return
+        if option_id == "act-change-key":
+            self._show_step("key")
+            return
+        if option_id == "act-change-provider":
+            self._show_step("provider")
+            return
+        if option_id.startswith("prov-"):
+            try:
+                index = int(option_id.split("-", 1)[1])
+            except ValueError:
+                return
+            if index < 0 or index >= len(self._providers):
+                return
+            self._selected_id = self._providers[index].id
+            self._model = self._providers[index].default_model
+            self._api_key = ""
+            self._base_url = ""
+            if self._selected_id == "ollama":
+                host = _ollama_host()
+                if not _discover_ollama_models():
+                    self._set_error(
+                        f"Ollama unreachable at {host}. Start it, then pick Ollama again."
+                    )
+                    return
+                self._show_step("model")
+            else:
+                self._show_step("key")
+            return
+        if option_id == "model-default":
+            assert self._selected_id
+            self._model = PROVIDERS[self._selected_id].default_model
+            self._show_step("verify")
+            return
+        if option_id.startswith("model-"):
+            try:
+                index = int(option_id.split("-", 1)[1])
+            except ValueError:
+                return
+            models = _models_for_provider(self._selected_id or "")
+            if index < 0 or index >= len(models):
+                return
+            self._model = models[index].id
+            self._show_step("verify")
+            return
+
+    @on(Input.Submitted, "#setup-api-key")
+    def on_api_key_submitted(self, event: Input.Submitted) -> None:
+        event.stop()
+        self._advance_from_key()
+
+    @on(Input.Submitted, "#setup-base-url")
+    def on_base_url_submitted(self, event: Input.Submitted) -> None:
+        event.stop()
+        key = self.query_one("#setup-api-key", Input)
+        if not key.value.strip():
+            key.focus()
+            return
+        self._advance_from_key()

{pairwit-0.0.2 → pairwit-0.0.4}/pairwit/util/env.py

@@ -53,3 +53,47 @@ def _env_flag(name: str, *, default: bool = True) -> bool:
     if value is None:
         return default
     return value.strip().lower() not in ("0", "false", "no", "off")
+
+
+def upsert_pairwit_env(values: dict[str, str]) -> Path:
+    """Write/update keys in `~/.pairwit/.env` and apply them to the process env.
+
+    Preserves unrelated lines and comments. Creates the home dir if needed.
+    """
+    path = Path.home() / ".pairwit" / ".env"
+    path.parent.mkdir(parents=True, exist_ok=True)
+
+    cleaned = {key: value.strip() for key, value in values.items() if value and value.strip()}
+    if not cleaned:
+        return path
+
+    existing_lines: list[str] = []
+    if path.is_file():
+        existing_lines = path.read_text(encoding="utf-8").splitlines()
+
+    seen: set[str] = set()
+    out: list[str] = []
+    for line in existing_lines:
+        stripped = line.strip()
+        if not stripped or stripped.startswith("#") or "=" not in line:
+            out.append(line)
+            continue
+        key = stripped.split("=", 1)[0].strip()
+        if key in cleaned:
+            out.append(f"{key}={cleaned[key]}")
+            seen.add(key)
+        else:
+            out.append(line)
+
+    for key, value in cleaned.items():
+        if key not in seen:
+            out.append(f"{key}={value}")
+        os.environ[key] = value
+
+    # Keys already rewritten above still need process env updates.
+    for key, value in cleaned.items():
+        os.environ[key] = value
+
+    text = "\n".join(out).rstrip() + "\n"
+    path.write_text(text, encoding="utf-8")
+    return path

{pairwit-0.0.2 → pairwit-0.0.4}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "pairwit"
-version = "0.0.2"
+version = "0.0.4"
 description = "Consent-first coding agent for your terminal (Plan/Build, approvals, /schedule)"
 readme = "README.md"
 requires-python = ">=3.10"
@@ -41,7 +41,7 @@ packages = ["pairwit"]
 "pairwit/assets/pairwit-mascot-8bit.png" = "pairwit/assets/pairwit-mascot-8bit.png"
 
 [tool.hatch.build.targets.sdist]
-include = [
+only-include = [
   "pairwit",
   "README.md",
   "pyproject.toml",

pairwit-0.0.2/site/README.md

@@ -1,106 +0,0 @@
-# pairwit.dev site
-
-Static site for [pairwit.dev](https://pairwit.dev).
-
-| Page | File |
-|---|---|
-| Landing | `index.html` |
-| User guide | `guide.html` |
-| Styles (brand locked) | `styles.css` |
-| Behavior (howto walkthrough) | `script.js` |
-
-## Brand — LOCKED
-
-Do not change fonts, palette, or light theme without an explicit brand decision.
-Matches the kimicode-light TUI.
-
-**Visual references (product UI):**
-
-Marketing page uses crisp HTML/`pw-frame` terminal recreations (same chrome everywhere). Soft JPEG captures are archived until we shoot retina PNGs.
-
-| File | What it documents |
-|---|---|
-| `assets/pairwit-mascot-8bit.png` | 8-bit cat + 2-wheel robot mascot (nav, hero, mocks, OG, favicon source) |
-| `assets/favicon.ico` / `favicon-16.png` / `favicon-32.png` / `favicon-48.png` / `apple-touch-icon.png` | Brand icons from the mascot |
-| `favicon.ico` (site root) | Browser auto-discovery at `/favicon.ico` |
-| `docs/site-captures/ref-desk.png` | Older desk capture (soft JPEG) |
-| `docs/site-captures/ref-chat.png` | Older chat capture (soft JPEG) |
-| `site/assets/shot-desk.png` / `shot-chat.png` | Cropped exports — interim only |
-
-How-to + feature mocks on the landing stay faithful to the live TUI chrome. Site uses the PNG; TUI welcome uses an ASCII sprite of the same cat-robot (`WelcomeMascot`) — half-block PNG downscales look muddy in terminal. PNG also ships in `pairwit/assets/`.
-
-| Token | Value | Role |
-|---|---|---|
-| Canvas | `#FDFCF5` | Page / TUI background |
-| Alt surface | `#F5F4F1` | Section bands, code chips |
-| Surface | `#FFFFFF` | Cards / shells |
-| Text | `#3D3929` | Primary ink |
-| Muted | `#8A8580` | Secondary copy |
-| Accent | `#0079BF` | Links, step numbers, grips |
-| Accent deep | `#026AA7` | Hover |
-| Border | `#E8E4D9` | Rules / chrome |
-| Green | `#6BAA84` | Success / completion tokens |
-| Orange | `#D4A574` | Cost / warm accents |
-| Brand font | **Sora** | Pairwit wordmark, headings |
-| Body font | **IBM Plex Sans** | Prose |
-| Mono font | **IBM Plex Mono** | Commands, shortcuts |
-
-Theme: light only (no dark mode on the marketing site).
-
-## Next (do not skip) — agent reminder
-
-**Status:** not done yet. Finish before calling the marketing site “shipped.”
-
-1. ~~**Mobile-first polish**~~ — done (nav menu, stacked hero/howto desk, safe-area, 44px targets). Re-check on real devices before ship.
-2. **Cross-browser** — verify Chromium, Safari (desktop + iOS), Firefox; check `background-clip: text`, sticky nav, clipboard copy fallback already in `script.js`.
-3. ~~**gtag**~~ — GA4 `G-LJ45HH53S5` on `index.html` + `guide.html`. Consent banner still optional later.
-4. ~~**Deploy → Cloudflare Pages**~~ — project `pairwit` live at https://pairwit.pages.dev. Custom domains `pairwit.dev` / `www` registered but **DNS pending** (CNAME → `pairwit.pages.dev` or move zone to Cloudflare).
-
-## Deploy status
-
-| Target | URL |
-|---|---|
-| Pages production | https://pairwit.pages.dev |
-| Custom domain | `pairwit.dev` + `www` added on Pages (DNS still pending) |
-
-### Redeploy
-
-Requires Node ≥ 22:
-
-```bash
-export NVM_DIR="$HOME/.nvm" && . "$NVM_DIR/nvm.sh" && nvm use 22
-cd site
-npx wrangler@latest pages deploy . --project-name pairwit --branch main --commit-dirty=true
-```
-
-### DNS for pairwit.dev
-
-Zone **pairwit.dev** is on Cloudflare (status pending until nameservers update).
-
-**At Hostinger (registrar)** set nameservers to:
-
-- `kristin.ns.cloudflare.com`
-- `quentin.ns.cloudflare.com`
-
-Then remove Hostinger parking DNS. Apex + `www` CNAMEs to `pairwit.pages.dev` are set in the Cloudflare zone (proxied).
-
-Dashboard: https://dash.cloudflare.com → select **pairwit.dev** → Overview (shows nameserver instructions).
-
-
-```bash
-cd site
-python3 -m http.server 8080
-# open http://127.0.0.1:8080
-# guide: http://127.0.0.1:8080/guide.html
-```
-
-## Temporary Hostinger fallback
-
-Only if Pages is not ready yet:
-
-1. Hostinger → manage **pairwit.dev**
-2. Upload `index.html`, `guide.html`, `styles.css`, `script.js` (+ optional `assets/`) to `public_html/`
-3. Visit https://pairwit.dev
-
-Install one-liner on the page: `pip install pairwit && pairwit`  
-(Agent release on PyPI is still gated — update copy when you green-light the full package.)