sliceagent 0.1.3__tar.gz → 0.1.5__tar.gz

{sliceagent-0.1.3 → sliceagent-0.1.5}/CHANGELOG.md

@@ -5,6 +5,20 @@ this project aims for [Semantic Versioning](https://semver.org/).
 
 ## [Unreleased]
 
+## [0.1.5] — 2026-07-02
+
+### Changed
+- Wizard step order is now **provider → model → key** ("choose what you want, then prove you can") —
+  the key is the last thing typed, so the live test follows it immediately.
+
+## [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.

{sliceagent-0.1.3 → sliceagent-0.1.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sliceagent
-Version: 0.1.3
+Version: 0.1.5
 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

{sliceagent-0.1.3 → sliceagent-0.1.5}/src/sliceagent/__init__.py

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

{sliceagent-0.1.3 → sliceagent-0.1.5}/src/sliceagent/onboarding.py

@@ -58,14 +58,15 @@ def _masked_input(prompt_text: str, fallback):
 
 
 def _pick(options: list, default: int = 0):
-    """Arrow-key selector for the wizard (reuses the TUI's _arrow_select: ↑/↓ or ←/→ + Enter).
-    Returns the index; raises KeyboardInterrupt on Esc (→ the wizard's normal 'cancelled' path);
-    returns None when a selector can't safely run so the caller falls back to typed input."""
+    """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 _arrow_select
+        from .tui import _menu_select
     except ImportError:
         return None
-    idx = _arrow_select(options, default=default)
+    idx = _menu_select(options, default=default)
     if idx == -1:
         raise KeyboardInterrupt
     return idx
@@ -260,12 +261,8 @@ def run_init(*, inp=input, getpw=None, llm_factory=None, home=None) -> int:
         existing = _read_config(path).get("providers")
         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 (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
+        # ORDER (user-decided): provider → MODEL → key. "Choose what you want, then prove you can" —
+        # the key is the last thing typed, so the live test follows it immediately.
         picked_model = None
         if fancy:
             cur = existing.get("model") or model
@@ -282,6 +279,12 @@ def run_init(*, inp=input, getpw=None, llm_factory=None, home=None) -> int:
         else:
             model = (inp(f"  Model [{existing.get('model') or model or 'required'}]: ").strip()
                      or existing.get("model") or model)
+        existing_key = existing.get("api_key") or ""
+        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
     except (EOFError, KeyboardInterrupt):
         out("\n  cancelled."); return 1
     if not key:

{sliceagent-0.1.3 → sliceagent-0.1.5}/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.5/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)