Add interactive prompts, command completion, and model filtering

- Implemented SlashCompleter for command completion based on user input.
- Added interactive choice prompts for selecting providers and models.
- Introduced model filtering logic to ensure only valid chat models are presented.
- Created tests for new features including command completion and model listing.
- Established suite-wide guards to prevent real HTTP requests during tests.
- Enhanced user experience by echoing typed responses in prompts.

Author: DevPatils

CLAUDE.md

@@ -72,6 +72,11 @@ turn's `.messages` back in as `history` — that is the *only* behavioural diffe
 `history` is copied, not mutated, so an interrupted turn cannot leave the caller with
 a transcript containing unanswered tool calls (which the API rejects).
 
+Everything that reads a keypress lives in `agent/prompts.py` (pickers, confirm, secret
+entry) and `agent/completion.py` (slash completion). `agent/models.py` asks a provider
+what it will actually accept, filtering `/models` down to ids that can drive a
+tool-calling loop — an embedding id in the picker is a 400 waiting to happen.
+
 **Rendering stays in `agent/ui.py`.** The loop emits events and never prints, so the
 benchmark adapter runs it with no console attached. Anything that makes `agent_loop`
 aware of a terminal breaks that.
@@ -190,6 +195,28 @@ These encode failures already hit; changing them will silently break runs.
   prints, and `ui.glyph()` falls back to ASCII when the encoding is narrow. The same
   applies to rich's box-drawing: `banner()` picks `box.ASCII` from `ascii_only()`
   rather than trusting rich's terminal detection.
+- **Tool schemas are narrowed per provider on the way out** (`tools_for`). The union
+  types (`["integer","string"]`) exist because Groq validates the model's arguments
+  server-side; Gemini's schema layer is OpenAPI-derived and cannot express a union at
+  all. So `TOOLS` stays canonical and each provider gets its own shape. `_rebuild_client`
+  re-narrows on `/provider`, or the next turn 400s on a schema built for the provider
+  just left.
+- **Anything the user types at a prompt must be echoed by prompt_toolkit, not
+  `input()`.** `input()` writes straight to the terminal while rich is still repainting
+  a spinner over the same line, so the keystrokes vanish and the user answers the
+  permission gate blind. `ui._read_answer` and `prompts.confirm` both own the line.
+- **Enter approves only what is safe to approve by reflex.** The permission prompt
+  defaults to yes, because approving reads is most of what it does — but not for
+  `Risk.DANGEROUS` or anything `outside_root`.
+- **A picker with no terminal cancels; it never guesses.** `prompts.choose` returns
+  `None` when stdin is not a tty. Returning the first option would silently change a
+  provider or model in a scripted run.
+- **The suite makes no network calls, and `tests/conftest.py` enforces it.** A test that
+  called `main()` loaded the developer's `.env`, found a real key and spent tokens on a
+  live request. httpx is blocked; the Docker tests use requests and still work.
+- **`load_dotenv` must be given `find_dotenv(usecwd=True)`.** The default searches
+  upward from the calling *file*, which inside a pipx install is site-packages — so an
+  installed `dietcode` never saw the `.env` in the directory the user was standing in.
 
 ## Constraints from the plan
 

agent/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "0.4.2"
+__version__ = "0.5.0"
 
 from .loop import AgentResult, agent_loop, make_client
 from .sandbox import DockerExecutor, Executor, LocalExecutor, SandboxError, ShellResult

agent/cli.py

@@ -35,6 +35,7 @@
     with_project_context,
 )
 from .permissions import PermissionGate, Policy, deny_all
+from .prompts import confirm
 from .repl import Session
 from .sandbox import (
     DEFAULT_CPUS,
@@ -46,7 +47,7 @@
     SandboxError,
 )
 from .subagent import SPAWN_TOOL, make_spawn_handler
-from .tools import TOOLS
+from .tools import tools_for
 from .ui import FAIL, Renderer, make_approver, turn_footer, use_utf8_stdout
 
 SUBCOMMANDS = {"login", "logout", "auth", "doctor"}
@@ -195,7 +196,9 @@ def wants_sandbox(args: argparse.Namespace) -> bool:
     return bool(args.sandbox or args.container or args.mount or args.no_network)
 
 
-def make_executor(args: argparse.Namespace, console: Console) -> tuple[Any, list]:
+def make_executor(
+    args: argparse.Namespace, console: Console, renderer: Renderer | None = None
+) -> tuple[Any, list]:
     if not wants_sandbox(args):
         root = Path(args.workdir).resolve()
         inner = LocalExecutor(root)
@@ -209,7 +212,7 @@ def make_executor(args: argparse.Namespace, console: Console) -> tuple[Any, list
             approver = deny_all  # unreachable while yes_to_everything is set
         elif sys.stdin.isatty():
             policy = Policy()
-            approver = make_approver(console)
+            approver = make_approver(console, renderer)
         else:
             # Nothing can be asked, so nothing destructive may happen. Silently
             # approving here is how an automated run rewrites someone's files.
@@ -246,6 +249,10 @@ def build_agent_extras(
     """The optional bits: project instructions and sub-agent delegation."""
     extras: dict[str, Any] = {}
 
+    # Always set, because the schemas one provider requires are the ones
+    # another rejects. Whichever provider the user picked has to work.
+    extras["tools"] = tools_for(getattr(args, "provider", None) or default_provider())
+
     if getattr(args, "context", True):
         context, source = load_project_context(
                 "." if wants_sandbox(args) else args.workdir
@@ -255,7 +262,7 @@ def build_agent_extras(
             console.print(f"[dim]using project instructions from {source}[/dim]")
 
     if getattr(args, "subagents", False):
-        extras["tools"] = [*TOOLS, SPAWN_TOOL]
+        extras["tools"] = [*extras["tools"], SPAWN_TOOL]
         extras["extra_tool_handlers"] = {
             "spawn_subagent": make_spawn_handler(
                 executor, client, model, context_budget=args.context_budget
@@ -264,9 +271,14 @@ def build_agent_extras(
     return extras
 
 
-def run_once(args: argparse.Namespace, executor: Any, client: Any, model: str) -> int:
-    console = Console(quiet=args.quiet and not args.json)
-    renderer = Renderer(console, show_steps=args.steps)
+def run_once(
+    args: argparse.Namespace,
+    executor: Any,
+    client: Any,
+    model: str,
+    console: Console,
+    renderer: Renderer,
+) -> int:
     started = time.monotonic()
     try:
         result = agent_loop(
@@ -333,9 +345,12 @@ def main(argv: list[str] | None = None) -> int:
     # .env is a convenience for running from a checkout; installed users have a
     # saved login instead. Optional so the package does not hard-depend on it.
     try:
-        from dotenv import load_dotenv
+        from dotenv import find_dotenv, load_dotenv
 
-        load_dotenv()
+        # usecwd, because the default searches upward from *this file*. Inside
+        # a pipx install that is site-packages, so an installed dietcode never
+        # saw the .env sitting in the directory the user was standing in.
+        load_dotenv(find_dotenv(usecwd=True))
     except ImportError:
         pass
 
@@ -356,8 +371,27 @@ def main(argv: list[str] | None = None) -> int:
 
     try:
         api_key, base_url, model = resolve_model_config(args)
+    except AuthError as exc:
+        # Dead-ending on "no credentials" makes the user go read the help, come
+        # back, and run a different command. Offer to fix it right here instead.
+        if not sys.stdin.isatty():
+            console.print(f"[red]{exc}[/red]")
+            return 2
+        console.print(f"[orange3]{exc}[/orange3]\n")
+        if not confirm(console, "Set one up now?"):
+            return 2
+        if login(console, args.provider, None) != 0:
+            return 2
+        try:
+            api_key, base_url, model = resolve_model_config(args)
+        except AuthError as retry_exc:
+            console.print(f"[red]{retry_exc}[/red]")
+            return 2
+        console.print()
+
+    try:
         client = make_client(api_key=api_key, base_url=base_url)
-    except (AuthError, RuntimeError) as exc:
+    except RuntimeError as exc:
         console.print(f"[red]{exc}[/red]")
         return 2
 
@@ -368,8 +402,9 @@ def main(argv: list[str] | None = None) -> int:
         if stale:
             console.print(f"[dim]cleaned up {stale} orphaned container(s)[/dim]")
 
+    renderer = Renderer(console, show_steps=args.steps)
     try:
-        executor, mounts = make_executor(args, console)
+        executor, mounts = make_executor(args, console, renderer)
     except SandboxError as exc:
         # Docker is optional now that --here exists, so a missing daemon should
         # be a signpost rather than a dead end.
@@ -385,7 +420,7 @@ def main(argv: list[str] | None = None) -> int:
 
     try:
         if args.task:
-            return run_once(args, executor, client, model)
+            return run_once(args, executor, client, model, console, renderer)
         return Session(
             executor,
             client,
@@ -399,6 +434,7 @@ def main(argv: list[str] | None = None) -> int:
             max_total_tokens=args.max_tokens,
             provider=args.provider or default_provider(),
             extras=build_agent_extras(args, executor, client, model, console),
+            renderer=renderer,
         ).run()
     finally:
         executor.close()

agent/commands.py

@@ -25,37 +25,30 @@
     set_default_provider,
     store_key,
 )
+from .prompts import Choice, ask_secret, choose
 from .ui import BRAND, DETAIL, FAIL, MUTED, NOTE, OK, TOOL, WARN, glyph
 
 
-def _prompt_secret(console: Console, label: str) -> str:
-    """Read a key without echoing it."""
-    import getpass
-
-    if not sys.stdin.isatty():
-        # Piped input: read a line so `echo $KEY | dietcode login` works.
-        return sys.stdin.readline().strip()
-    try:
-        return getpass.getpass(f"{label}: ")
-    except (EOFError, KeyboardInterrupt):
-        console.print()
-        return ""
-
-
 def login(console: Console, provider: str | None, api_key: str | None) -> int:
     """Save an API key for a provider."""
     if provider is None:
-        console.print(f"[{TOOL}]Which provider?[/{TOOL}]")
-        for spec in PROVIDERS.values():
+        provider = choose(
+            console,
+            "Which provider?",
+            [
+                Choice(spec.name, spec.label, f"free tier {glyph('dot')} {spec.signup_url}"
+                       if spec.name in ("groq", "gemini") else spec.signup_url)
+                for spec in PROVIDERS.values()
+            ],
+        )
+        if provider is None:
+            # Also the path a piped run takes: there is nobody to ask, so say
+            # which flag would have answered the question.
             console.print(
-                f"  [{NOTE}]{spec.name:<8}[/{NOTE}] [{MUTED}]{spec.label} "
-                f"{glyph('dot')} keys at {spec.signup_url}[/{MUTED}]"
+                f"[{MUTED}]cancelled[/{MUTED}] "
+                f"[{MUTED}]{glyph('dash')} or name one: "
+                f"dietcode login --provider {'|'.join(PROVIDERS)}[/{MUTED}]"
             )
-        console.print()
-        try:
-            provider = input(f"provider [{list(PROVIDERS)[0]}]: ").strip() or list(PROVIDERS)[0]
-        except (EOFError, KeyboardInterrupt):
-            console.print()
             return 130
 
     try:
@@ -69,7 +62,7 @@ def login(console: Console, provider: str | None, api_key: str | None) -> int:
             f"[{MUTED}]Get a key at {spec.signup_url} "
             f"{glyph('dot')} input is hidden[/{MUTED}]"
         )
-        api_key = _prompt_secret(console, f"{spec.label} API key")
+        api_key = ask_secret(f"{spec.label} API key")
 
     api_key = clean_key(api_key or "")
     if not api_key:
@@ -172,12 +165,13 @@ def report(good: bool, label: str, detail: str, fix: str = "") -> None:
 
     docker = shutil.which("docker")
     if docker is None:
+        # Not a failure: Docker is only needed for --sandbox, so reporting it
+        # as broken would send people chasing an install they do not need.
         report(
-            False,
+            True,
             "docker",
             "not installed",
-            "optional: without it use `dietcode --here` to work in the current "
-            "directory instead of a container",
+            "optional -- only needed for `dietcode --sandbox`",
         )
     else:
         try:
@@ -196,7 +190,7 @@ def report(good: bool, label: str, detail: str, fix: str = "") -> None:
             running,
             "docker",
             detail,
-            "start Docker Desktop, or use `dietcode --here` to skip the sandbox",
+            "only needed for --sandbox; start Docker Desktop if you want it",
         )
 
     configured = [spec.name for spec, masked, _ in credential_status() if masked]
@@ -209,7 +203,7 @@ def report(good: bool, label: str, detail: str, fix: str = "") -> None:
 
     console.print()
     if ok:
-        console.print(f"[{OK}]{glyph('tick')} ready[/{OK}] [{MUTED}]try: dietcode --here[/{MUTED}]")
+        console.print(f"[{OK}]{glyph('tick')} ready[/{OK}] [{MUTED}]try: dietcode[/{MUTED}]")
         return 0
     console.print(f"[{WARN}]fix the items above, then run `dietcode doctor` again[/{WARN}]")
     return 1

agent/completion.py

@@ -0,0 +1,39 @@
+"""Slash-command completion.
+
+WordCompleter offers its candidates for whatever word is under the cursor, so
+typing an ordinary task and pressing space popped the command list up mid
+sentence. This only completes when the *whole line* is a single token starting
+with "/" -- which is the only moment a command could be what you meant.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Iterable, Mapping
+
+from prompt_toolkit.completion import CompleteEvent, Completer, Completion
+from prompt_toolkit.document import Document
+
+
+class SlashCompleter(Completer):
+    def __init__(self, commands: Mapping[str, str]):
+        self._commands = dict(commands)
+
+    def get_completions(
+        self, document: Document, complete_event: CompleteEvent
+    ) -> Iterable[Completion]:
+        text = document.text_before_cursor
+
+        # Only at the very start of the line, and only while still typing the
+        # command itself. "/model gemini" is past the command, and "fix /tmp"
+        # is a path, not a command.
+        if not text.startswith("/") or " " in text:
+            return
+
+        for name, description in self._commands.items():
+            if name.startswith(text):
+                yield Completion(
+                    name,
+                    start_position=-len(text),
+                    display=name,
+                    display_meta=description,
+                )