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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: weio-cli
-Version: 0.1.0
+Version: 0.2.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:

{weio_cli-0.1.0 → weio_cli-0.2.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:

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

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "weio-cli"
-version = "0.1.0"
+version = "0.2.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.2.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.2.0"

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

@@ -128,6 +128,20 @@ def cmd_chat(args) -> int:
     return 0
 
 
+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 +253,10 @@ 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("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 +271,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"}
+    # 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)

{weio_cli-0.1.0 → weio_cli-0.2.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.2.0/src/weio_cli/tui.py

@@ -0,0 +1,321 @@
+"""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))
+        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.1.0 → weio_cli-0.2.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.2.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:

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

@@ -7,6 +7,7 @@ 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.egg-info/PKG-INFO
 src/weio_cli.egg-info/SOURCES.txt
 src/weio_cli.egg-info/dependency_links.txt

weio_cli-0.2.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