weio-cli 0.1.0__tar.gz → 0.3.0__tar.gz

{weio_cli-0.1.0/src/weio_cli.egg-info → weio_cli-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: weio-cli
-Version: 0.1.0
+Version: 0.3.0
 Summary: Weio — an agentic coding assistant that routes inference through your Weio account.
 Author: We I/O Labs
 License: MIT
@@ -17,6 +17,7 @@ Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: httpx>=0.24
+Requires-Dist: prompt_toolkit>=3.0
 Dynamic: license-file
 
 # weio-cli
@@ -44,8 +45,36 @@ export WEIO_API_KEY="weio_sk_…"
 
 ## Use
 
+### Interactive TUI (default)
+
+Run `weio` with no arguments to drop into an interactive coding session — like a
+local pair-programmer in your terminal:
+
+```bash
+cd my-project
+weio
+```
+
+```
+weio › add a /health route to app.py that returns {"ok": true}
+
+weio: I'll add a health check route…
+  ● edit app.py
+  --- a/app.py
+  +++ b/app.py
+  @@ …
+  Apply 1 change(s)? [y/N] y
+  ✓ applied 1 change(s). (/undo to revert)
+```
+
+Slash commands: `/add <file>`, `/drop <file>`, `/files`, `/auto` (auto-apply),
+`/model <id>`, `/undo`, `/clear`, `/cwd`, `/help`, `/exit`. Arrow-up recalls
+history. Files you mention or `/add` are kept in context and re-read each turn.
+
+### One-shot & other commands
+
 ```bash
-# Run a coding task in the current directory (reads & edits files):
+# Run a single coding task non-interactively (reads & edits files):
 weio "add error handling to the fetch() in api.py"
 
 # Add specific files to the context:
@@ -64,6 +93,19 @@ weio ping
 Edits are shown as a diff and require confirmation before anything is written
 (use `-y`/`--yes` to apply automatically). New files are created as needed.
 
+## Updating
+
+weio-cli checks PyPI once a day (fail-silent) and prints a one-line notice when a
+newer version is available. To upgrade:
+
+```bash
+weio update           # upgrades in place via pip
+# or
+pip install -U weio-cli
+```
+
+Disable the check with `WEIO_NO_UPDATE_CHECK=1`.
+
 ## Configuration
 
 | Setting | Flag | Env | Config file |

{weio_cli-0.1.0 → weio_cli-0.3.0}/README.md

@@ -23,8 +23,36 @@ export WEIO_API_KEY="weio_sk_…"
 
 ## Use
 
+### Interactive TUI (default)
+
+Run `weio` with no arguments to drop into an interactive coding session — like a
+local pair-programmer in your terminal:
+
+```bash
+cd my-project
+weio
+```
+
+```
+weio › add a /health route to app.py that returns {"ok": true}
+
+weio: I'll add a health check route…
+  ● edit app.py
+  --- a/app.py
+  +++ b/app.py
+  @@ …
+  Apply 1 change(s)? [y/N] y
+  ✓ applied 1 change(s). (/undo to revert)
+```
+
+Slash commands: `/add <file>`, `/drop <file>`, `/files`, `/auto` (auto-apply),
+`/model <id>`, `/undo`, `/clear`, `/cwd`, `/help`, `/exit`. Arrow-up recalls
+history. Files you mention or `/add` are kept in context and re-read each turn.
+
+### One-shot & other commands
+
 ```bash
-# Run a coding task in the current directory (reads & edits files):
+# Run a single coding task non-interactively (reads & edits files):
 weio "add error handling to the fetch() in api.py"
 
 # Add specific files to the context:
@@ -43,6 +71,19 @@ weio ping
 Edits are shown as a diff and require confirmation before anything is written
 (use `-y`/`--yes` to apply automatically). New files are created as needed.
 
+## Updating
+
+weio-cli checks PyPI once a day (fail-silent) and prints a one-line notice when a
+newer version is available. To upgrade:
+
+```bash
+weio update           # upgrades in place via pip
+# or
+pip install -U weio-cli
+```
+
+Disable the check with `WEIO_NO_UPDATE_CHECK=1`.
+
 ## Configuration
 
 | Setting | Flag | Env | Config file |

{weio_cli-0.1.0 → weio_cli-0.3.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "weio-cli"
-version = "0.1.0"
+version = "0.3.0"
 description = "Weio — an agentic coding assistant that routes inference through your Weio account."
 readme = "README.md"
 requires-python = ">=3.9"
@@ -19,7 +19,7 @@ classifiers = [
     "Programming Language :: Python :: 3",
     "Topic :: Software Development :: Code Generators",
 ]
-dependencies = ["httpx>=0.24"]
+dependencies = ["httpx>=0.24", "prompt_toolkit>=3.0"]
 
 [project.urls]
 Homepage = "https://weio.ai"

{weio_cli-0.1.0 → weio_cli-0.3.0}/src/weio_cli/__init__.py

@@ -1,3 +1,3 @@
 """Weio CLI — an agentic coding assistant that routes inference through your Weio account."""
 
-__version__ = "0.1.0"
+__version__ = "0.3.0"

{weio_cli-0.1.0 → weio_cli-0.3.0}/src/weio_cli/cli.py

@@ -128,6 +128,30 @@ def cmd_chat(args) -> int:
     return 0
 
 
+def cmd_update(args) -> int:
+    from . import updater
+    latest = updater.check_for_update(force=True)
+    if not latest:
+        print(_c(f"weio-cli {__version__} is up to date.", "32"))
+        return 0
+    print(_c(f"Updating weio-cli {__version__} → {latest}…", "36"))
+    return updater.self_update()
+
+
+def cmd_tui(args) -> int:
+    try:
+        client = _make_client(args)
+    except WeioError as e:
+        print(_c(str(e), "31"), file=sys.stderr)
+        return 2
+    root = Path(getattr(args, "dir", ".") or ".").resolve()
+    if not root.is_dir():
+        print(_c(f"Not a directory: {root}", "31"), file=sys.stderr)
+        return 2
+    from .tui import run_tui
+    return run_tui(client, root, max_tokens=_max_tokens(args))
+
+
 def cmd_code(args) -> int:
     try:
         client = _make_client(args)
@@ -239,6 +263,13 @@ def build_parser() -> argparse.ArgumentParser:
     sp = sub.add_parser("chat", parents=[common], help="Interactive chat")
     sp.set_defaults(func=cmd_chat)
 
+    sp = sub.add_parser("tui", parents=[common], help="Interactive coding TUI (default when run with no args)")
+    sp.add_argument("--dir", "-C", default=".", help="Project directory (default: cwd)")
+    sp.set_defaults(func=cmd_tui)
+
+    sp = sub.add_parser("update", parents=[common], help="Update weio-cli to the latest version")
+    sp.set_defaults(func=cmd_update)
+
     sp = sub.add_parser("code", parents=[common], help="Run a coding task in a directory")
     sp.add_argument("message")
     sp.add_argument("--file", "-f", action="append", help="Add a file to the context (repeatable)")
@@ -253,9 +284,12 @@ def main(argv=None) -> int:
     argv = list(sys.argv[1:] if argv is None else argv)
     parser = build_parser()
 
-    # Bare `weio "do something"` defaults to the `code` command.
-    known = {"login", "ping", "ask", "chat", "code"}
-    if argv and argv[0] not in known and not argv[0].startswith("-"):
+    known = {"login", "ping", "ask", "chat", "code", "tui", "update"}
+    # Bare `weio` (no args) → interactive coding TUI, like Claude Code.
+    if not argv:
+        argv = ["tui"]
+    # Bare `weio "do something"` (a message, not a flag/command) → one-shot code.
+    elif argv[0] not in known and not argv[0].startswith("-"):
         argv = ["code", *argv]
 
     args = parser.parse_args(argv)
@@ -263,10 +297,21 @@ def main(argv=None) -> int:
         parser.print_help()
         return 1
     try:
-        return args.func(args)
+        rc = args.func(args)
     except KeyboardInterrupt:
         print()
         return 130
+    # Throttled, fail-silent update notice (skipped for tui — it shows its own
+    # in the header — and for the update command itself).
+    if args.command not in ("update", "tui"):
+        try:
+            from . import updater
+            notice = updater.update_notice()
+            if notice:
+                print(_c("\n" + notice, "33"), file=sys.stderr)
+        except Exception:
+            pass
+    return rc
 
 
 if __name__ == "__main__":

{weio_cli-0.1.0 → weio_cli-0.3.0}/src/weio_cli/client.py

@@ -73,6 +73,21 @@ class WeioClient:
                 if r.status_code >= 400:
                     body = r.read().decode("utf-8", "replace")
                     raise WeioError(f"Gateway error {r.status_code}: {body[:300]}")
+
+                ctype = r.headers.get("content-type", "")
+                # Not all gateways honor stream=true. If the response isn't SSE,
+                # read the whole JSON body and yield its content in one shot.
+                if "text/event-stream" not in ctype:
+                    body = r.read().decode("utf-8", "replace")
+                    try:
+                        content = json.loads(body)["choices"][0]["message"]["content"]
+                        if content:
+                            yield content
+                    except (KeyError, IndexError, json.JSONDecodeError) as e:
+                        raise WeioError(f"Unexpected response shape: {body[:300]}") from e
+                    return
+
+                saw_delta = False
                 for line in r.iter_lines():
                     if not line or not line.startswith("data:"):
                         continue
@@ -82,9 +97,14 @@ class WeioClient:
                     try:
                         delta = json.loads(data)["choices"][0].get("delta", {}).get("content")
                         if delta:
+                            saw_delta = True
                             yield delta
                     except (KeyError, IndexError, json.JSONDecodeError):
                         continue
+                if not saw_delta:
+                    # SSE content-type but no usable deltas — fall back to non-stream.
+                    yield self.chat(messages, max_tokens=max_tokens,
+                                    temperature=temperature, model=model)
         except httpx.HTTPError as e:
             raise WeioError(f"Network error talking to {self.base}: {e}") from e
 

weio_cli-0.3.0/src/weio_cli/tui.py

@@ -0,0 +1,328 @@
+"""Interactive coding TUI — a Claude Code-style REPL for weio.
+
+Launch with bare `weio` (or `weio tui`). You get a persistent prompt where you
+chat with the model; when it proposes file changes they're shown as a diff and
+applied (with confirmation, or auto in /auto mode). Slash commands manage the
+session. Uses prompt_toolkit when available, with a plain readline fallback.
+"""
+from __future__ import annotations
+
+import os
+import sys
+from pathlib import Path
+
+from . import __version__, coder
+from .client import WeioClient, WeioError
+
+try:
+    from prompt_toolkit import PromptSession
+    from prompt_toolkit.history import FileHistory
+    from prompt_toolkit.completion import WordCompleter
+    from prompt_toolkit.styles import Style
+    _HAS_PTK = True
+except Exception:  # pragma: no cover
+    _HAS_PTK = False
+
+
+# --------------------------------------------------------------------------- #
+# Colors
+# --------------------------------------------------------------------------- #
+_TTY = sys.stdout.isatty()
+
+def _c(s: str, code: str) -> str:
+    return f"\033[{code}m{s}\033[0m" if _TTY else s
+
+DIM = "2"; BOLD = "1"; CYAN = "36"; GREEN = "32"; YELLOW = "33"; RED = "31"; BLUE = "34"
+
+
+INTERACTIVE_SYSTEM = """You are Weio, an expert pair-programmer running as an interactive coding agent in the user's terminal, inside their project directory.
+
+You hold a normal conversation AND make code changes. When you change files, emit EDIT BLOCKS:
+
+```edit relative/path/to/file.ext
+<<<<<<< SEARCH
+<exact lines that currently exist>
+=======
+<replacement lines>
+>>>>>>> REPLACE
+```
+
+- SEARCH must match the current file contents EXACTLY. For a NEW file, leave SEARCH empty.
+- You may emit several blocks (and several per file). Keep edits minimal and focused.
+- Before/after edit blocks, talk to the user normally: explain your plan briefly and summarize what you changed.
+- Only edit files relevant to the request. If you need a file you haven't been shown, ask for it (the user can /add it).
+- When the user just asks a question, answer conversationally with no edit blocks."""
+
+HELP = """Commands:
+  /help            show this help
+  /add <path>      add a file to the working context (re-read each turn)
+  /drop <path>     remove a file from context
+  /files           list files in context
+  /diff            show the last proposed (unapplied) edits
+  /auto            toggle auto-apply of edits (default: confirm each time)
+  /model <id>      switch model (e.g. auto, low, mid, pro)
+  /undo            revert the last applied edit set
+  /clear           clear the conversation history
+  /cwd [path]      show or change the working directory
+  /exit, /quit     leave (Ctrl-D also works)
+
+Type anything else to talk to Weio. It can edit files in the project directly."""
+
+
+class Repl:
+    def __init__(self, client: WeioClient, root: Path, max_tokens: int = 4096):
+        self.client = client
+        self.root = root
+        self.max_tokens = max_tokens
+        self.messages: list[dict] = [{"role": "system", "content": INTERACTIVE_SYSTEM}]
+        self.context_files: list[str] = []
+        self.auto_apply = False
+        self.pending: list[coder.Edit] = []
+        self.undo_stack: list[list[tuple]] = []  # each entry: [(path, old_text_or_None)]
+        self._session = None
+        # prompt_toolkit needs a real terminal; fall back to plain input otherwise
+        # (pipes, CI, dumb terminals).
+        if _HAS_PTK and sys.stdin.isatty() and sys.stdout.isatty():
+            cfg_dir = Path(os.environ.get("WEIO_CONFIG_DIR", str(Path.home() / ".weio")))
+            cfg_dir.mkdir(parents=True, exist_ok=True)
+            self._session = PromptSession(
+                history=FileHistory(str(cfg_dir / "tui_history")),
+                completer=WordCompleter(
+                    ["/help", "/add", "/drop", "/files", "/diff", "/auto", "/model",
+                     "/undo", "/clear", "/cwd", "/exit", "/quit"],
+                    sentence=True,
+                ),
+            )
+
+    # ----- input -----
+    def _read(self) -> str | None:
+        prompt = "weio › "
+        try:
+            if self._session is not None:
+                return self._session.prompt(
+                    prompt,
+                    bottom_toolbar=f" {self.root.name}  ·  model={self.client.model}  ·  "
+                                   f"{'AUTO-APPLY' if self.auto_apply else 'confirm edits'}  ·  /help",
+                )
+            return input(_c(prompt, CYAN))
+        except (EOFError, KeyboardInterrupt):
+            return None
+
+    # ----- context -----
+    def _context_block(self) -> str:
+        blocks = []
+        for rel in list(self.context_files):
+            fp = self.root / rel
+            if not fp.is_file():
+                continue
+            try:
+                blocks.append(f"=== FILE: {rel} ===\n{fp.read_text(encoding='utf-8')}")
+            except (OSError, UnicodeDecodeError):
+                continue
+        return "\n\n".join(blocks)
+
+    # ----- turn -----
+    def _turn(self, text: str):
+        user_content = text
+        ctx = self._context_block()
+        # Auto-include any path-like tokens that exist and aren't already in context
+        auto_ctx, _ = coder.gather_context(text, [], self.root)
+        extra = auto_ctx if auto_ctx and not ctx else ""
+        if ctx or extra:
+            user_content += "\n\nFILES IN CONTEXT:\n" + (ctx or extra)
+
+        self.messages.append({"role": "user", "content": user_content})
+
+        sys.stdout.write(_c("\nweio: ", GREEN))
+        sys.stdout.flush()
+        acc = ""
+        try:
+            for delta in self.client.chat_stream(self.messages, max_tokens=self.max_tokens,
+                                                  temperature=0.2):
+                acc += delta
+                sys.stdout.write(delta)
+                sys.stdout.flush()
+            print()
+        except WeioError as e:
+            print("\n" + _c(str(e), RED))
+            self.messages.pop()
+            return
+        self.messages.append({"role": "assistant", "content": acc})
+
+        edits = coder.parse_edits(acc)
+        if edits:
+            self._handle_edits(edits)
+
+    def _handle_edits(self, edits: list[coder.Edit]):
+        results, errors = [], []
+        for e in edits:
+            res, err = coder.apply_edit(e, self.root)
+            if err:
+                errors.append(err)
+            elif res:
+                results.append(res)
+        for res in results:
+            tag = _c("● new ", GREEN) if res.created else _c("● edit ", YELLOW)
+            print("\n" + tag + _c(res.path, BOLD))
+            if res.created:
+                body = res.new_text if len(res.new_text) < 1200 else res.new_text[:1200] + "\n…"
+                print(body)
+            else:
+                print(_color_diff(coder.unified_diff(res.path, res.old_text, res.new_text)))
+        for err in errors:
+            print(_c("  skip: " + err, RED))
+        if not results:
+            return
+        if not self.auto_apply:
+            ans = self._confirm(f"Apply {len(results)} change(s)? [y/N] ")
+            if ans not in ("y", "yes"):
+                print(_c("  not applied.", DIM))
+                return
+        undo_entry = []
+        for res in results:
+            fp = self.root / res.path
+            old = fp.read_text(encoding="utf-8") if fp.exists() else None
+            undo_entry.append((res.path, old))
+            fp.parent.mkdir(parents=True, exist_ok=True)
+            fp.write_text(res.new_text, encoding="utf-8")
+        self.undo_stack.append(undo_entry)
+        for res in results:
+            if res.path not in self.context_files:
+                self.context_files.append(res.path)  # keep edited files in context
+        print(_c(f"  ✓ applied {len(results)} change(s). (/undo to revert)", GREEN))
+
+    def _confirm(self, msg: str) -> str:
+        try:
+            if self._session is not None:
+                return self._session.prompt(msg).strip().lower()
+            return input(_c(msg, CYAN)).strip().lower()
+        except (EOFError, KeyboardInterrupt):
+            print()
+            return "n"
+
+    # ----- slash commands -----
+    def _slash(self, text: str) -> bool:
+        parts = text.strip().split(maxsplit=1)
+        cmd = parts[0].lower()
+        arg = parts[1].strip() if len(parts) > 1 else ""
+        if cmd in ("/exit", "/quit"):
+            return False
+        elif cmd == "/help":
+            print(HELP)
+        elif cmd == "/add":
+            if not arg:
+                print(_c("  usage: /add <path>", DIM))
+            elif (self.root / arg).is_file():
+                if arg not in self.context_files:
+                    self.context_files.append(arg)
+                print(_c(f"  added {arg}", GREEN))
+            else:
+                print(_c(f"  no such file: {arg}", RED))
+        elif cmd == "/drop":
+            if arg in self.context_files:
+                self.context_files.remove(arg)
+                print(_c(f"  dropped {arg}", GREEN))
+            else:
+                print(_c(f"  not in context: {arg}", DIM))
+        elif cmd == "/files":
+            if self.context_files:
+                for f in self.context_files:
+                    print("  " + f)
+            else:
+                print(_c("  (no files in context — /add <path> or just mention them)", DIM))
+        elif cmd == "/auto":
+            self.auto_apply = not self.auto_apply
+            print(_c(f"  auto-apply {'ON' if self.auto_apply else 'OFF'}", YELLOW))
+        elif cmd == "/model":
+            if arg:
+                self.client.model = arg
+                print(_c(f"  model = {arg}", GREEN))
+            else:
+                print("  model =", self.client.model)
+        elif cmd == "/clear":
+            self.messages = [{"role": "system", "content": INTERACTIVE_SYSTEM}]
+            print(_c("  conversation cleared.", GREEN))
+        elif cmd == "/cwd":
+            if arg:
+                p = (self.root / arg).resolve() if not os.path.isabs(arg) else Path(arg)
+                if p.is_dir():
+                    self.root = p
+                    print(_c(f"  cwd = {p}", GREEN))
+                else:
+                    print(_c(f"  not a directory: {arg}", RED))
+            else:
+                print("  cwd =", self.root)
+        elif cmd == "/undo":
+            self._undo()
+        elif cmd == "/diff":
+            print(_c("  (edits are shown when proposed; nothing pending)", DIM))
+        else:
+            print(_c(f"  unknown command: {cmd} (/help)", RED))
+        return True
+
+    def _undo(self):
+        if not self.undo_stack:
+            print(_c("  nothing to undo.", DIM))
+            return
+        entry = self.undo_stack.pop()
+        for path, old in entry:
+            fp = self.root / path
+            if old is None:
+                try:
+                    fp.unlink()
+                except OSError:
+                    pass
+            else:
+                fp.write_text(old, encoding="utf-8")
+        print(_c(f"  ↩ reverted {len(entry)} file(s).", GREEN))
+
+    # ----- main loop -----
+    def run(self) -> int:
+        ok = self.client.ping()
+        print(_c(f"weio {__version__}", BOLD) + _c(f"  ·  {self.root}", DIM))
+        print(_c(f"  {self.client.base}  ·  " +
+                 ("connected" if ok else "⚠ cannot reach gateway / bad key"),
+                 GREEN if ok else RED))
+        try:
+            from .updater import update_notice
+            notice = update_notice()
+            if notice:
+                print(_c("  ⬆ " + notice, YELLOW))
+        except Exception:
+            pass
+        print(_c("  Type a request, or /help. Ctrl-D to exit.\n", DIM))
+        while True:
+            text = self._read()
+            if text is None:
+                print()
+                break
+            text = text.strip()
+            if not text:
+                continue
+            if text.startswith("/"):
+                if not self._slash(text):
+                    break
+                continue
+            self._turn(text)
+        print(_c("bye.", DIM))
+        return 0
+
+
+def _color_diff(diff: str) -> str:
+    if not _TTY or not diff:
+        return diff or "  (no textual diff)"
+    out = []
+    for line in diff.splitlines():
+        if line.startswith("+") and not line.startswith("+++"):
+            out.append(_c(line, GREEN))
+        elif line.startswith("-") and not line.startswith("---"):
+            out.append(_c(line, RED))
+        elif line.startswith("@@"):
+            out.append(_c(line, CYAN))
+        else:
+            out.append(line)
+    return "\n".join(out)
+
+
+def run_tui(client: WeioClient, root: Path, max_tokens: int = 4096) -> int:
+    return Repl(client, root, max_tokens=max_tokens).run()

weio_cli-0.3.0/src/weio_cli/updater.py

@@ -0,0 +1,114 @@
+"""Update checking + self-update.
+
+A throttled, fail-silent check against PyPI (once per day) tells the user when a
+newer weio-cli is published. `weio update` upgrades in place. Disable the check
+with WEIO_NO_UPDATE_CHECK=1.
+"""
+from __future__ import annotations
+
+import json
+import os
+import subprocess
+import sys
+import time
+from pathlib import Path
+from typing import Optional
+
+from . import __version__
+
+INDEX_JSON = os.environ.get("WEIO_UPDATE_INDEX", "https://pypi.org/pypi/weio-cli/json")
+_CACHE_NAME = "update_check.json"
+_TTL_HOURS = 24
+
+
+def _cache_dir() -> Path:
+    return Path(os.environ.get("WEIO_CONFIG_DIR", str(Path.home() / ".weio")))
+
+
+def _parse_version(v: str) -> tuple:
+    """Lenient numeric version tuple, e.g. '0.10.2' -> (0, 10, 2)."""
+    out = []
+    for part in (v or "").split("."):
+        num = ""
+        for ch in part:
+            if ch.isdigit():
+                num += ch
+            else:
+                break
+        out.append(int(num) if num else 0)
+    return tuple(out) or (0,)
+
+
+def is_newer(latest: str, current: str) -> bool:
+    return _parse_version(latest) > _parse_version(current)
+
+
+def fetch_latest(timeout: float = 2.5) -> Optional[str]:
+    try:
+        import httpx
+        r = httpx.get(INDEX_JSON, timeout=timeout,
+                      headers={"User-Agent": f"weio-cli/{__version__}"})
+        if r.status_code != 200:
+            return None
+        return r.json()["info"]["version"]
+    except Exception:
+        return None
+
+
+def check_for_update(current: str = __version__, *, ttl_hours: int = _TTL_HOURS,
+                     force: bool = False) -> Optional[str]:
+    """Return the latest version string if newer than `current`, else None.
+
+    Throttled to once per ttl_hours via a cache file; never raises.
+    """
+    if os.environ.get("WEIO_NO_UPDATE_CHECK") == "1":
+        return None
+    try:
+        cache = _cache_dir() / _CACHE_NAME
+        data = {}
+        if cache.exists():
+            try:
+                data = json.loads(cache.read_text())
+            except Exception:
+                data = {}
+        now = time.time()
+        latest = data.get("latest")
+        last = float(data.get("last_check", 0) or 0)
+
+        if force or not latest or (now - last) > ttl_hours * 3600:
+            fetched = fetch_latest()
+            if fetched:
+                latest = fetched
+                try:
+                    cache.parent.mkdir(parents=True, exist_ok=True)
+                    cache.write_text(json.dumps({"last_check": now, "latest": latest}))
+                except Exception:
+                    pass
+
+        if latest and is_newer(latest, current):
+            return latest
+    except Exception:
+        pass
+    return None
+
+
+def update_notice(current: str = __version__) -> Optional[str]:
+    """One-line, color-free notice if an update is available (for printing)."""
+    latest = check_for_update(current)
+    if not latest:
+        return None
+    return (f"weio-cli {latest} is available (you have {current}). "
+            f"Update with: weio update")
+
+
+def self_update(pre: bool = False) -> int:
+    """Upgrade weio-cli in place using the running interpreter's pip."""
+    cmd = [sys.executable, "-m", "pip", "install", "--upgrade", "weio-cli"]
+    if pre:
+        cmd.append("--pre")
+    print(f"Running: {' '.join(cmd)}")
+    try:
+        return subprocess.call(cmd)
+    except Exception as e:
+        print(f"Update failed: {e}", file=sys.stderr)
+        return 1

{weio_cli-0.1.0 → weio_cli-0.3.0/src/weio_cli.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: weio-cli
-Version: 0.1.0
+Version: 0.3.0
 Summary: Weio — an agentic coding assistant that routes inference through your Weio account.
 Author: We I/O Labs
 License: MIT
@@ -17,6 +17,7 @@ Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: httpx>=0.24
+Requires-Dist: prompt_toolkit>=3.0
 Dynamic: license-file
 
 # weio-cli
@@ -44,8 +45,36 @@ export WEIO_API_KEY="weio_sk_…"
 
 ## Use
 
+### Interactive TUI (default)
+
+Run `weio` with no arguments to drop into an interactive coding session — like a
+local pair-programmer in your terminal:
+
+```bash
+cd my-project
+weio
+```
+
+```
+weio › add a /health route to app.py that returns {"ok": true}
+
+weio: I'll add a health check route…
+  ● edit app.py
+  --- a/app.py
+  +++ b/app.py
+  @@ …
+  Apply 1 change(s)? [y/N] y
+  ✓ applied 1 change(s). (/undo to revert)
+```
+
+Slash commands: `/add <file>`, `/drop <file>`, `/files`, `/auto` (auto-apply),
+`/model <id>`, `/undo`, `/clear`, `/cwd`, `/help`, `/exit`. Arrow-up recalls
+history. Files you mention or `/add` are kept in context and re-read each turn.
+
+### One-shot & other commands
+
 ```bash
-# Run a coding task in the current directory (reads & edits files):
+# Run a single coding task non-interactively (reads & edits files):
 weio "add error handling to the fetch() in api.py"
 
 # Add specific files to the context:
@@ -64,6 +93,19 @@ weio ping
 Edits are shown as a diff and require confirmation before anything is written
 (use `-y`/`--yes` to apply automatically). New files are created as needed.
 
+## Updating
+
+weio-cli checks PyPI once a day (fail-silent) and prints a one-line notice when a
+newer version is available. To upgrade:
+
+```bash
+weio update           # upgrades in place via pip
+# or
+pip install -U weio-cli
+```
+
+Disable the check with `WEIO_NO_UPDATE_CHECK=1`.
+
 ## Configuration
 
 | Setting | Flag | Env | Config file |

{weio_cli-0.1.0 → weio_cli-0.3.0}/src/weio_cli.egg-info/SOURCES.txt

@@ -7,6 +7,8 @@ src/weio_cli/cli.py
 src/weio_cli/client.py
 src/weio_cli/coder.py
 src/weio_cli/config.py
+src/weio_cli/tui.py
+src/weio_cli/updater.py
 src/weio_cli.egg-info/PKG-INFO
 src/weio_cli.egg-info/SOURCES.txt
 src/weio_cli.egg-info/dependency_links.txt

weio_cli-0.3.0/src/weio_cli.egg-info/requires.txt

@@ -0,0 +1,2 @@
+httpx>=0.24
+prompt_toolkit>=3.0

weio_cli-0.1.0/src/weio_cli.egg-info/requires.txt

@@ -1 +0,0 @@
-httpx>=0.24