sliceagent 0.1.2__tar.gz → 0.1.4__tar.gz

{sliceagent-0.1.2 → sliceagent-0.1.4}/CHANGELOG.md

@@ -5,6 +5,33 @@ this project aims for [Semantic Versioning](https://semver.org/).
 
 ## [Unreleased]
 
+## [0.1.4] — 2026-07-02
+
+### Fixed
+- **Wizard menus render as a proper vertical list.** The single-line selector wrapped with six long
+  provider labels, and its clear-one-line redraw stacked copies of itself down the screen. New
+  `_menu_select`: one option per row, width-clamped labels (wrap impossible), in-place cursor-up
+  redraws, explicit `\r\n` in raw mode. PTY-tested, including the anti-stacking invariant.
+
+## [0.1.3] — 2026-07-02
+
+The five-door provider lineup + a wizard that feels like one.
+
+### Added
+- **Providers**: OpenRouter (hundreds of models, one key — now the first door), OpenAI,
+  **Anthropic/Claude** (new — via Anthropic's OpenAI-compatible endpoint), DeepSeek, Moonshot/Kimi,
+  plus custom endpoints. All five ride the single adapter — zero new dependencies.
+- **OpenRouter quirks**: reasoning intent maps to OpenRouter's unified `reasoning` object (works
+  WITH tools — the raw `reasoning_effort` param never could); tool-calling requests pin routing to
+  hosts that honor every param (`require_parameters`) so nothing silently degrades; per-call
+  `usage.cost` is parsed into the cost meter.
+- `ANTHROPIC_API_KEY` / `DEEPSEEK_API_KEY` / `OPENROUTER_API_KEY` accepted as key fallbacks.
+
+### Changed
+- **Wizard UX**: API key shows `******` as you type (no more invisible field); provider and model
+  are arrow-key menus (↑/↓ + Enter, Esc cancels) with per-provider model suggestions +
+  "type another model id…". Scripted/CI runs keep the plain typed flow.
+
 ## [0.1.2] — 2026-07-02
 
 Nothing may hang the user — three fixes from a live first-run reproduction.

{sliceagent-0.1.2 → sliceagent-0.1.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sliceagent
-Version: 0.1.2
+Version: 0.1.4
 Summary: A coding agent with a new context-engineering framework: bounded, deterministic, reconstructed context (slice architecture) — built for long-horizon work.
 Author: TT-Wang
 License-Expression: MIT
@@ -145,11 +145,10 @@ Footprint is light (no torch). `pip install -e .` works for a clone too. Homebre
 ## Quickstart
 
 ```bash
-sliceagent init            # guided setup: provider, API key, model → ~/.sliceagent/config.toml (tests your key)
-sliceagent                 # start the agent
+sliceagent                 # that's it — first run walks you through setup (provider, API key, live-tested), then you're in
 ```
 
-`init` writes the config so the next run needs no env vars. Prefer env vars? Export **both** `LLM_API_KEY` and `AGENT_MODEL` (plus `LLM_BASE_URL` for non-OpenAI endpoints) and skip `init` — there is no default model; sliceagent never picks one for you. Discover every setting with `sliceagent config --list`.
+Setup happens once, in-process, and writes `~/.sliceagent/config.toml` (0600) so every later run just starts. Re-configure anytime with `sliceagent init` (add/switch providers). Prefer env vars? Export **both** `LLM_API_KEY` and `AGENT_MODEL` (plus `LLM_BASE_URL` for non-OpenAI endpoints) — there is no default model; sliceagent never picks one for you. Discover every setting with `sliceagent config --list`.
 
 → Full walkthrough in **[QUICKSTART.md](QUICKSTART.md)** · **[CONTRIBUTING.md](CONTRIBUTING.md)** · **[CHANGELOG.md](CHANGELOG.md)**
 

{sliceagent-0.1.2 → sliceagent-0.1.4}/QUICKSTART.md

@@ -15,12 +15,14 @@ installed by default; everything still works without it (plain stdout).
 ## 2. Set up your provider
 
 ```bash
-sliceagent init
+sliceagent
 ```
 
-`init` walks you through it: pick a provider (Moonshot/Kimi, OpenAI, DeepSeek, or a custom OpenAI-compatible
-endpoint), paste your API key (hidden), choose a model. It then **tests the key with one request** and writes
-`~/.sliceagent/config.toml` (mode `0600` — it holds your key). The next `sliceagent` just works.
+Nothing to memorize — the **first run walks you through setup automatically**: pick a provider
+(OpenRouter — hundreds of models with one key — or OpenAI, Anthropic/Claude, DeepSeek, Moonshot/Kimi, or a custom OpenAI-compatible endpoint), paste your API key (hidden),
+choose a model. It **tests the key with one request**, writes `~/.sliceagent/config.toml` (mode `0600` —
+it holds your key), and drops you straight into the session. Every later `sliceagent` just starts.
+(Re-configure anytime — add or switch providers — with `sliceagent init`.)
 
 Prefer environment variables? Skip `init` and export them instead:
 

{sliceagent-0.1.2 → sliceagent-0.1.4}/README.md

@@ -112,11 +112,10 @@ Footprint is light (no torch). `pip install -e .` works for a clone too. Homebre
 ## Quickstart
 
 ```bash
-sliceagent init            # guided setup: provider, API key, model → ~/.sliceagent/config.toml (tests your key)
-sliceagent                 # start the agent
+sliceagent                 # that's it — first run walks you through setup (provider, API key, live-tested), then you're in
 ```
 
-`init` writes the config so the next run needs no env vars. Prefer env vars? Export **both** `LLM_API_KEY` and `AGENT_MODEL` (plus `LLM_BASE_URL` for non-OpenAI endpoints) and skip `init` — there is no default model; sliceagent never picks one for you. Discover every setting with `sliceagent config --list`.
+Setup happens once, in-process, and writes `~/.sliceagent/config.toml` (0600) so every later run just starts. Re-configure anytime with `sliceagent init` (add/switch providers). Prefer env vars? Export **both** `LLM_API_KEY` and `AGENT_MODEL` (plus `LLM_BASE_URL` for non-OpenAI endpoints) — there is no default model; sliceagent never picks one for you. Discover every setting with `sliceagent config --list`.
 
 → Full walkthrough in **[QUICKSTART.md](QUICKSTART.md)** · **[CONTRIBUTING.md](CONTRIBUTING.md)** · **[CHANGELOG.md](CHANGELOG.md)**
 

{sliceagent-0.1.2 → sliceagent-0.1.4}/install.sh

@@ -96,9 +96,8 @@ cat <<'EOF'
 
   ✓ sliceagent installed.
 
-  Next:
-    sliceagent init     # guided setup: provider, API key, model (tests your key)
-    sliceagent          # start the agent
+  Next — just one command:
+    sliceagent          # first run walks you through setup (provider, API key), then you're chatting
 
   If 'sliceagent' isn't found, open a NEW terminal (PATH was just updated).
   Docs: https://github.com/TT-Wang/sliceagent

{sliceagent-0.1.2 → sliceagent-0.1.4}/src/sliceagent/__init__.py

@@ -1,3 +1,3 @@
 """sliceagent — a memory-native coding agent (deterministic, bounded, reconstructed context)."""
 
-__version__ = "0.1.2"
+__version__ = "0.1.4"

{sliceagent-0.1.2 → sliceagent-0.1.4}/src/sliceagent/cli.py

@@ -171,7 +171,8 @@ def main() -> None:
 
     def _key_present() -> bool:
         return bool(os.environ.get("LLM_API_KEY") or os.environ.get("OPENAI_API_KEY")
-                    or os.environ.get("MOONSHOT_API_KEY"))
+                    or os.environ.get("ANTHROPIC_API_KEY") or os.environ.get("DEEPSEEK_API_KEY")
+                    or os.environ.get("OPENROUTER_API_KEY") or os.environ.get("MOONSHOT_API_KEY"))
 
     def _first_run_setup(reason: str) -> bool:
         """First-run UX: a bare interactive `sliceagent` with nothing configured drops STRAIGHT into the

{sliceagent-0.1.2 → sliceagent-0.1.4}/src/sliceagent/llm.py

@@ -81,6 +81,9 @@ def _usage_dict(raw) -> dict | None:
     }
     if cache_read:
         usage["cached_tokens"] = cache_read                              # legacy key (only when present)
+    _cost = getattr(raw, "cost", None)                                   # OpenRouter: authoritative $ per call
+    if isinstance(_cost, (int, float)) and _cost >= 0:
+        usage["cost_usd"] = float(_cost)
     return usage
 
 
@@ -189,7 +192,9 @@ class OpenAILLM:
         # export OPENAI_API_KEY) — the surface the user configures says "LLM", not a provider name.
         # Resolve the ENDPOINT first: the proxy choice below depends on which provider it is.
         kwargs: dict = {"api_key": api_key or os.environ.get("LLM_API_KEY")
-                        or os.environ.get("OPENAI_API_KEY") or os.environ.get("MOONSHOT_API_KEY")}
+                        or os.environ.get("OPENAI_API_KEY") or os.environ.get("ANTHROPIC_API_KEY")
+                        or os.environ.get("DEEPSEEK_API_KEY") or os.environ.get("OPENROUTER_API_KEY")
+                        or os.environ.get("MOONSHOT_API_KEY")}
         resolved_base = base_url or os.environ.get("LLM_BASE_URL") or os.environ.get("OPENAI_BASE_URL")
         if not resolved_base and os.environ.get("MOONSHOT_API_KEY") and not (
                 os.environ.get("LLM_API_KEY") or os.environ.get("OPENAI_API_KEY")):
@@ -466,6 +471,12 @@ class OpenAILLM:
         from .model_catalog import capability
         r = self.reasoning
         model, base = self.model.lower(), self._base_url.lower()
+        if "openrouter" in base:
+            # OpenRouter's UNIFIED reasoning object translates effort per upstream vendor (OpenAI
+            # reasoning_effort / Anthropic thinking budget / Gemini thinkingLevel) and — unlike raw
+            # reasoning_effort on chat/completions — works WITH tools. "full" stays provider-default.
+            effort = {"fast": "low", "high": "high", "max": "high"}.get(r)
+            return {"extra_body": {"reasoning": {"effort": effort}}} if effort else {}
         if "deepseek" in model or "deepseek" in base:
             return {"extra_body": {"thinking": {"type": "disabled"}}} if r == "fast" else {}
         if not capability(self.model, self._base_url).supports_reasoning_effort:
@@ -637,6 +648,12 @@ class OpenAILLM:
         self._merge_kwargs(kwargs, self._cache_routing_kwargs())  # session-stable cache routing (0 added tokens)
         self._merge_kwargs(kwargs, self._reasoning_kwargs())
         self._merge_kwargs(kwargs, self._cache_kwargs(messages))
+        if "openrouter" in self._base_url.lower() and tools:
+            # OpenRouter routes one model slug across MANY hosts; some serve quantizations with broken
+            # tool calling, and unsupported params are DROPPED silently by default. require_parameters
+            # pins routing to hosts that honor every param we sent — a silent degrade becomes a visible
+            # error instead (the exact failure class behind the old reasoning-effort ceiling).
+            self._merge_kwargs(kwargs, {"extra_body": {"provider": {"require_parameters": True}}})
         # Provider quirk (isolated here, llm-agnostic): some reasoning models (gpt-5.5) reject
         # reasoning_effort TOGETHER with function tools on /v1/chat/completions (400 — "use /v1/responses").
         # Once seen, drop reasoning_effort whenever tools are present so we degrade to default reasoning

{sliceagent-0.1.2 → sliceagent-0.1.4}/src/sliceagent/onboarding.py

@@ -13,14 +13,65 @@ import os
 from .envspec import GROUPS, REGISTRY, current_value
 
 # provider presets: key → (label, base_url, default_model). 'custom' prompts for the base_url.
+# The lineup: one AGGREGATOR door (OpenRouter — breadth, one key) + four first-party doors
+# (OpenAI, Anthropic, DeepSeek, Moonshot). Anthropic rides its OpenAI-compatible endpoint, so all
+# five share the single OpenAILLM adapter — no per-provider SDKs.
 PROVIDERS = {
-    "1": ("moonshot", "Moonshot (Kimi)", "https://api.moonshot.cn/v1", "kimi-k2.7-code"),
+    "1": ("openrouter", "OpenRouter (hundreds of models, one key)", "https://openrouter.ai/api/v1", "openai/gpt-5.5"),
     "2": ("openai", "OpenAI", "", "gpt-5.5"),
-    "3": ("deepseek", "DeepSeek", "https://api.deepseek.com/v1", "deepseek-chat"),
-    "4": ("custom", "Custom OpenAI-compatible endpoint", "", ""),
+    "3": ("anthropic", "Anthropic (Claude)", "https://api.anthropic.com/v1", "claude-sonnet-5"),
+    "4": ("deepseek", "DeepSeek", "https://api.deepseek.com/v1", "deepseek-chat"),
+    "5": ("moonshot", "Moonshot (Kimi)", "https://api.moonshot.cn/v1", "kimi-k2.7-code"),
+    "6": ("custom", "Custom OpenAI-compatible endpoint", "", ""),
+}
+
+# wizard model MENU per provider — suggestions for the arrow picker, NOT a cap: "type another…"
+# always accepts any model id (the catalog/pricing layers stay the capability source of truth).
+MODEL_SUGGESTIONS = {
+    "openrouter": ["openai/gpt-5.5", "anthropic/claude-sonnet-5", "deepseek/deepseek-chat",
+                   "moonshotai/kimi-k2.7"],
+    "openai": ["gpt-5.5", "gpt-5", "gpt-5-mini", "o3"],
+    "anthropic": ["claude-sonnet-5", "claude-opus-4-8", "claude-haiku-4-5"],
+    "deepseek": ["deepseek-chat", "deepseek-reasoner"],
+    "moonshot": ["kimi-k2.7-code", "kimi-k2-0905-preview"],
+    "custom": [],
 }
 
 
+def _tty() -> bool:
+    import sys
+    try:
+        return sys.stdin.isatty() and sys.stdout.isatty()
+    except Exception:  # noqa: BLE001
+        return False
+
+
+def _masked_input(prompt_text: str, fallback):
+    """API-key entry with VISIBLE feedback — asterisks per keystroke (prompt_toolkit is_password)
+    instead of getpass's fully-invisible field, which first-run users read as 'nothing is happening'.
+    Falls back to getpass when the TUI stack is absent or anything goes wrong."""
+    try:
+        from prompt_toolkit import prompt as _ptk_prompt
+        return _ptk_prompt(prompt_text, is_password=True)
+    except (ImportError, OSError, EOFError):
+        return fallback(prompt_text)
+
+
+def _pick(options: list, default: int = 0):
+    """Arrow-key selector for the wizard — the VERTICAL menu (_menu_select: one option per row), NOT
+    the single-line _arrow_select, whose one-line redraw wraps and stacks with 6 long provider labels
+    (live-repro'd). Returns the index; raises KeyboardInterrupt on Esc (→ the wizard's normal
+    'cancelled' path); returns None when a selector can't safely run → caller falls back to typed."""
+    try:
+        from .tui import _menu_select
+    except ImportError:
+        return None
+    idx = _menu_select(options, default=default)
+    if idx == -1:
+        raise KeyboardInterrupt
+    return idx
+
+
 def _version() -> str:
     try:
         from . import __version__
@@ -182,11 +233,24 @@ def run_init(*, inp=input, getpw=None, llm_factory=None, home=None) -> int:
         if ans in ("n", "no"):
             out("  Leaving the existing config unchanged. Run `sliceagent` to start."); return 0
 
-    out("\n  Choose a provider:")
-    for k, (_id, label, base, model) in PROVIDERS.items():
-        out(f"    {k}. {label}" + (f"  ({model})" if model else ""))
+    # arrow-key niceties only on a REAL interactive run with the default input hooks — injected
+    # inp/getpw (tests, scripted runs) keep the typed flow byte-for-byte.
+    fancy = inp is input and getpw is __import__("getpass").getpass and _tty()
+    keys = sorted(PROVIDERS)
     try:
-        choice = inp("  > ").strip() or "1"
+        out("\n  Choose a provider (↑/↓ + Enter):" if fancy else "\n  Choose a provider:")
+        idx = None
+        if fancy:
+            labels = [f"{PROVIDERS[k][1]}" + (f"  — {PROVIDERS[k][3]}" if PROVIDERS[k][3] else "")
+                      for k in keys]
+            idx = _pick(labels)                       # Esc → KeyboardInterrupt → 'cancelled' below
+        if idx is not None:
+            choice = keys[idx]
+        else:                                          # typed fallback (no tty / selector unavailable)
+            for k in keys:
+                _id, label, _base, model0 = PROVIDERS[k]
+                out(f"    {k}. {label}" + (f"  ({model0})" if model0 else ""))
+            choice = inp("  > ").strip() or "1"
         pid, label, base_url, model = PROVIDERS.get(choice, PROVIDERS["1"])
         if pid == "custom":
             base_url = inp("  Base URL (OpenAI-compatible, e.g. https://host/v1): ").strip()
@@ -198,10 +262,27 @@ def run_init(*, inp=input, getpw=None, llm_factory=None, home=None) -> int:
         existing = existing.get(pid) if isinstance(existing, dict) else None
         existing = existing if isinstance(existing, dict) else {}
         existing_key = existing.get("api_key") or ""
-        key_prompt = "  API key (hidden, Enter to keep existing): " if existing_key else "  API key (hidden): "
-        key = getpw(key_prompt).strip() or existing_key
-        model = (inp(f"  Model [{existing.get('model') or model or 'required'}]: ").strip()
-                 or existing.get("model") or model)
+        key_prompt = ("  API key (typed as ******, Enter to keep existing): " if existing_key
+                      else "  API key (typed as ******): ") if fancy else (
+                      "  API key (hidden, Enter to keep existing): " if existing_key
+                      else "  API key (hidden): ")
+        key = (_masked_input(key_prompt, getpw) if fancy else getpw(key_prompt)).strip() or existing_key
+        picked_model = None
+        if fancy:
+            cur = existing.get("model") or model
+            opts = [m for m in ([cur] if cur else []) + MODEL_SUGGESTIONS.get(pid, []) if m]
+            opts = list(dict.fromkeys(opts)) + ["type another model id…"]
+            out("  Model (↑/↓ + Enter):")
+            midx = _pick(opts)
+            if midx is not None:
+                picked_model = None if opts[midx].startswith("type another") else opts[midx]
+                if picked_model is None:
+                    picked_model = inp("  Model id: ").strip()
+        if picked_model:
+            model = picked_model
+        else:
+            model = (inp(f"  Model [{existing.get('model') or model or 'required'}]: ").strip()
+                     or existing.get("model") or model)
     except (EOFError, KeyboardInterrupt):
         out("\n  cancelled."); return 1
     if not key:

{sliceagent-0.1.2 → sliceagent-0.1.4}/src/sliceagent/tui.py

@@ -1267,6 +1267,102 @@ def _arrow_select(options: list[str], default: int = 0) -> "int | None":
     return idx
 
 
+def _menu_select(options: list[str], default: int = 0) -> "int | None":
+    """VERTICAL arrow-key menu — one option per row: ↑/↓ (or ←/→) move, Enter chooses, Esc/Ctrl-C
+    cancels. Exists because the single-line _arrow_select WRAPS with long/many options, and its
+    clear-one-line redraw then stacks copies of itself down the screen (live-repro'd in the init
+    wizard's 6-entry provider menu). This sibling owns EXACTLY len(options) rows: labels are clamped
+    below the terminal width so a row can never wrap, and each redraw walks the cursor up over its
+    own rows. Raw-mode note: OPOST is off, so every line break is an explicit \\r\\n (the staircase
+    lesson). Same gates + return contract as _arrow_select: index | -1 cancelled | None when a
+    selector can't safely run (caller falls back to typed input)."""
+    import shutil
+    import sys
+    import threading
+    if threading.current_thread() is not threading.main_thread():
+        return None
+    if not (sys.stdin.isatty() and sys.stdout.isatty()):
+        return None
+    try:
+        import termios
+        import tty
+    except Exception:  # noqa: BLE001 — non-POSIX → typed fallback
+        return None
+    fd = sys.stdin.fileno()
+    try:
+        old = termios.tcgetattr(fd)
+    except Exception:  # noqa: BLE001
+        return None
+    width = max(20, shutil.get_terminal_size((80, 24)).columns - 8)
+    rows = [o if len(o) <= width else o[: width - 1] + "…" for o in options]
+    idx = default if 0 <= default < len(rows) else 0
+
+    def draw(first: bool = False) -> None:
+        if not first:
+            sys.stdout.write(f"\x1b[{len(rows)}A")            # walk back up over OUR rows only
+        parts = []
+        for i, o in enumerate(rows):
+            body = f"\x1b[7m ▸ {o} \x1b[0m" if i == idx else f"\x1b[2m   {o} \x1b[0m"
+            parts.append("\r\x1b[2K  " + body)
+        sys.stdout.write("\r\n".join(parts) + "\r\n")         # explicit \r\n: raw mode, OPOST off
+        sys.stdout.flush()
+
+    raw_entered = False
+    try:
+        tty.setraw(fd)
+        raw_entered = True
+        try:
+            termios.tcflush(fd, termios.TCIFLUSH)
+        except Exception:  # noqa: BLE001
+            pass
+        draw(first=True)
+        while True:
+            try:
+                data = os.read(fd, 16)                        # raw fd read — see _arrow_select's note
+            except OSError:
+                idx = -1
+                break
+            if not data:
+                idx = -1
+                break
+            if data[:1] in (b"\r", b"\n"):                     # Enter → choose
+                break
+            if data[:1] == b"\x03":                           # Ctrl-C → cancel
+                idx = -1
+                break
+            if data[:1] == b"\x1b":
+                if len(data) == 1:                            # bare ESC → cancel
+                    idx = -1
+                    break
+                if data[1:2] in (b"[", b"O"):
+                    arrow = data[2:3]
+                    if arrow in (b"B", b"C"):                 # ↓ / →
+                        idx = (idx + 1) % len(rows)
+                    elif arrow in (b"A", b"D"):               # ↑ / ←
+                        idx = (idx - 1) % len(rows)
+                    draw()
+                    if b"\r" in data[3:] or b"\n" in data[3:]:
+                        break
+                continue
+    except Exception:  # noqa: BLE001 — any I/O error → typed fallback, never corrupt the terminal
+        idx = None
+    finally:
+        if raw_entered:
+            try:
+                termios.tcsetattr(fd, termios.TCSADRAIN, old)
+            except Exception:  # noqa: BLE001
+                try:
+                    termios.tcsetattr(fd, termios.TCSANOW, old)
+                except Exception:  # noqa: BLE001
+                    pass
+            try:
+                sys.stdout.write("\r")                        # cursor already sits below the block
+                sys.stdout.flush()
+            except Exception:  # noqa: BLE001
+                pass
+    return idx
+
+
 def confirm(console: Console, name: str, detail: str, reason: str) -> str:
     """Approval prompt used by the permission hook when the TUI is active. Synchronous (no pt app
     is live mid-run), returns 'yes' | 'no' | 'always'. Arrow-key selectable; falls back to a typed

sliceagent-0.1.4/tests/test_menu_select.py

@@ -0,0 +1,109 @@
+"""PTY tests for _menu_select — the wizard's VERTICAL arrow menu. Regression for the live wizard bug:
+the single-line _arrow_select wrapped with 6 long provider labels and its one-line redraw stacked copies
+of itself down the screen. The vertical menu must (a) return the arrow-chosen index, (b) cancel on Esc,
+and (c) redraw IN PLACE — cursor-up over exactly its own N rows (the anti-stacking invariant).
+Run: PYTHONPATH=src python tests/test_menu_select.py   (skips cleanly where no pty is available)
+"""
+import os
+import pty
+import select
+import subprocess
+import sys
+import time
+
+_SRC = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..", "src")
+sys.path.insert(0, _SRC)
+
+CHECKS = []
+def check(fn):
+    CHECKS.append(fn)
+    return fn
+
+
+_OPTS = [f"Provider number {i} with a deliberately long label to force the old wrap bug ({i})"
+         for i in range(6)]
+
+_CHILD = (
+    "import os, sys\n"
+    "from sliceagent.tui import _menu_select\n"
+    f"opts = {_OPTS!r}\n"
+    "idx = _menu_select(opts, default=0)\n"
+    "os._exit(100 if idx is None else (99 if idx == -1 else 42 + idx))\n"
+)
+
+
+def _run(presses: list) -> tuple:
+    """Run the child on a pty; return (exit_code, output_bytes)."""
+    try:
+        master, slave = pty.openpty()
+    except OSError:
+        return None, b""
+    env = {**os.environ, "PYTHONPATH": os.path.abspath(_SRC), "COLUMNS": "120", "LINES": "40"}
+    p = subprocess.Popen([sys.executable, "-c", _CHILD], stdin=slave, stdout=slave,
+                         stderr=subprocess.DEVNULL, env=env, start_new_session=True)
+    os.close(slave)
+    buf = bytearray()
+    deadline = time.monotonic() + 15
+    sent = 0
+    while time.monotonic() < deadline and p.poll() is None:
+        r, _, _ = select.select([master], [], [], 0.1)
+        if r:
+            try:
+                buf.extend(os.read(master, 4096))
+            except OSError:
+                break
+        # feed keys only once the menu has rendered (its last row is on screen)
+        if sent < len(presses) and _OPTS[-1][:20].encode() in buf:
+            os.write(master, presses[sent]); sent += 1
+            time.sleep(0.15)
+    try:
+        p.wait(timeout=5)
+    except subprocess.TimeoutExpired:
+        p.kill(); p.wait()
+    try:
+        os.close(master)
+    except OSError:
+        pass
+    return p.returncode, bytes(buf)
+
+
+@check
+def down_down_enter_picks_the_third_option():
+    rc, _out = _run([b"\x1b[B", b"\x1b[B", b"\r"])
+    if rc is None:
+        return   # no pty here — skip
+    assert rc == 44, f"expected idx 2 (exit 44), got {rc}"
+
+
+@check
+def esc_cancels():
+    rc, _out = _run([b"\x1b"])
+    if rc is None:
+        return
+    assert rc == 99, f"expected cancel (exit 99), got {rc}"
+
+
+@check
+def redraw_is_in_place_not_stacked():
+    rc, out = _run([b"\x1b[B", b"\r"])
+    if rc is None:
+        return
+    assert rc == 43, f"expected idx 1 (exit 43), got {rc}"
+    # the anti-stacking invariant: every redraw walks the cursor UP over its own 6 rows
+    assert b"\x1b[6A" in out, "redraw must cursor-up over exactly its own rows (in-place, not stacking)"
+    # and rows never exceed the terminal width (wrap is what broke the single-line selector)
+    import re
+    plain = re.sub(rb"\x1b\[[0-9;]*[A-Za-z]", b"", out)
+    for line in plain.split(b"\r\n"):
+        assert len(line) <= 120, f"a rendered row exceeds the terminal width ({len(line)} cols) — wrap risk"
+
+
+if __name__ == "__main__":
+    ok = 0
+    for fn in CHECKS:
+        try:
+            fn(); ok += 1; print(f"PASS {fn.__name__}")
+        except Exception as e:  # noqa: BLE001
+            print(f"FAIL {fn.__name__}: {type(e).__name__}: {e}")
+    print(f"\n{ok}/{len(CHECKS)} passed")
+    sys.exit(0 if ok == len(CHECKS) else 1)

{sliceagent-0.1.2 → sliceagent-0.1.4}/tests/test_onboarding.py

@@ -134,7 +134,7 @@ class _OkLLM:
 def init_writes_a_valid_config_on_success():
     home = tempfile.mkdtemp(prefix="init-")
     rc = onboarding.run_init(
-        inp=_seq("1", ""),                 # provider=moonshot, model=default
+        inp=_seq("5", ""),                 # provider=moonshot (menu slot 5), model=default
         getpw=_seq("sk-test-key"),
         llm_factory=lambda model: _OkLLM(),
         home=home)
@@ -180,7 +180,7 @@ def init_offers_to_save_after_a_failed_key_test():
 def init_custom_provider_prompts_base_url():
     home = tempfile.mkdtemp(prefix="init-custom-")
     rc = onboarding.run_init(
-        inp=_seq("4", "https://my.host/v1", "my-model"),   # custom → base url → model
+        inp=_seq("6", "https://my.host/v1", "my-model"),   # custom → base url → model (menu: 6 = custom)
         getpw=_seq("k"),
         llm_factory=lambda model: _OkLLM(),
         home=home)
@@ -193,7 +193,7 @@ def init_custom_provider_prompts_base_url():
 @check
 def init_aborts_without_a_key():
     home = tempfile.mkdtemp(prefix="init-nokey-")
-    rc = onboarding.run_init(inp=_seq("1", ""), getpw=_seq(""), llm_factory=lambda m: _OkLLM(), home=home)
+    rc = onboarding.run_init(inp=_seq("5", ""), getpw=_seq(""), llm_factory=lambda m: _OkLLM(), home=home)
     assert rc == 1, "no key → abort"
     assert not os.path.exists(os.path.join(home, ".sliceagent", "config.toml"))
 
@@ -224,7 +224,7 @@ def write_config_is_atomic_and_cleans_up_on_failure():
 @check
 def init_merge_keeps_existing_providers():
     home = tempfile.mkdtemp(prefix="init-merge-")
-    onboarding.run_init(inp=_seq("1", ""), getpw=_seq("k-moon"), llm_factory=lambda m: _OkLLM(), home=home)
+    onboarding.run_init(inp=_seq("5", ""), getpw=_seq("k-moon"), llm_factory=lambda m: _OkLLM(), home=home)
     # 2nd init on the existing config: "Add/update? [Y/n]" → "" (yes) → provider 2 (openai) → model ""
     onboarding.run_init(inp=_seq("", "2", ""), getpw=_seq("k-oai"), llm_factory=lambda m: _OkLLM(), home=home)
     data = tomllib.load(open(os.path.join(home, ".sliceagent", "config.toml"), "rb"))
@@ -239,10 +239,10 @@ def reinit_blank_key_keeps_existing_key_for_the_same_provider():
     # prompt (no retype) must KEEP the saved key/model, not abort — the abort-on-blank behavior
     # (init_aborts_without_a_key) is only correct for a provider with no existing entry.
     home = tempfile.mkdtemp(prefix="init-reblank-")
-    onboarding.run_init(inp=_seq("1", ""), getpw=_seq("k-moon"), llm_factory=lambda m: _OkLLM(), home=home)
+    onboarding.run_init(inp=_seq("5", ""), getpw=_seq("k-moon"), llm_factory=lambda m: _OkLLM(), home=home)
     # 2nd init: "Add/update? [Y/n]" → "" (yes) → provider 1 (moonshot, already saved) → key "" (blank,
     # keep existing) → model "" (blank, keep existing)
-    rc = onboarding.run_init(inp=_seq("", "1", ""), getpw=_seq(""), llm_factory=lambda m: _OkLLM(), home=home)
+    rc = onboarding.run_init(inp=_seq("", "5", ""), getpw=_seq(""), llm_factory=lambda m: _OkLLM(), home=home)
     assert rc == 0, "blank key on an already-configured provider must NOT abort"
     data = tomllib.load(open(os.path.join(home, ".sliceagent", "config.toml"), "rb"))
     assert data["providers"]["moonshot"]["api_key"] == "k-moon", "the existing key must be kept, not wiped"
@@ -252,7 +252,7 @@ def reinit_blank_key_keeps_existing_key_for_the_same_provider():
 @check
 def config_use_switches_default_provider():
     home = tempfile.mkdtemp(prefix="cfg-use-")
-    onboarding.run_init(inp=_seq("1", ""), getpw=_seq("k1"), llm_factory=lambda m: _OkLLM(), home=home)
+    onboarding.run_init(inp=_seq("5", ""), getpw=_seq("k1"), llm_factory=lambda m: _OkLLM(), home=home)
     onboarding.run_init(inp=_seq("", "2", ""), getpw=_seq("k2"), llm_factory=lambda m: _OkLLM(), home=home)
     assert onboarding.run_config(["--use", "moonshot"], home=home) == 0
     data = tomllib.load(open(os.path.join(home, ".sliceagent", "config.toml"), "rb"))