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

weio_cli-0.5.0/PKG-INFO

@@ -0,0 +1,159 @@
+Metadata-Version: 2.4
+Name: weio-cli
+Version: 0.5.0
+Summary: Weio — an agentic coding assistant that routes inference through your Weio account.
+Author: We I/O Labs
+License: MIT
+Project-URL: Homepage, https://weio.ai
+Project-URL: Documentation, https://weio.ai/support
+Keywords: weio,ai,cli,coding-assistant,llm
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Software Development :: Code Generators
+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
+
+An agentic coding assistant that runs on your machine and routes inference
+through your [Weio](https://weio.ai) account.
+
+## Install
+
+```bash
+pip install weio-cli        # or: pipx install weio-cli
+```
+
+Requires Python 3.9+.
+
+## Authenticate
+
+```bash
+weio login            # opens your browser, sign in (incl. Google), key is created automatically
+```
+
+`weio login` starts a one-time local handshake, opens weio.ai in your browser to
+sign in, mints an API key for this device, and saves it to `~/.weio/config.json`.
+No copy-paste.
+
+Prefer to paste a key yourself? Generate one in **Settings → API & CLI** on
+weio.ai and:
+
+```bash
+weio login --no-browser     # paste your weio_sk_… key
+# or, per session:
+export WEIO_API_KEY="weio_sk_…"
+```
+
+Check what you're using:
+
+```bash
+weio usage            # tier, tokens used today, remaining, reset time
+```
+
+## Use
+
+### Interactive agent (default)
+
+Run `weio` with no arguments to start an autonomous coding agent in your terminal —
+like Claude Code / Codex. It reads files, searches, edits, and runs commands to
+complete your task, showing each step:
+
+```bash
+cd my-project
+weio
+```
+
+```
+weio › add a /health route to app.py and run the tests
+
+● Let me look at the app first.
+  📖 read_file app.py
+● Adding the route.
+  ✎ edit_file app.py
+  │ + @app.get("/health")
+  │ + def health(): return {"ok": True}
+  apply edit_file to app.py? [y/N] y
+● Verifying.
+  ❯ run_command pytest -q
+  │ exit=0  …  5 passed
+✔ Added /health and confirmed tests pass.
+```
+
+The agent uses tools: **read_file, list_dir, search, edit_file, write_file,
+run_command**. File paths are confined to the project directory.
+
+Slash commands: `/model <id>`, `/approval <mode>`, `/steps <n>`, `/settings`,
+`/undo`, `/clear`, `/cwd`, `/help`, `/exit`.
+
+### Approval modes
+
+Control how much the agent does without asking (`/approval` or `weio config approval`):
+
+| Mode | Edits | Shell commands |
+|---|---|---|
+| `suggest` (default) | ask each time | ask each time |
+| `auto-edit` | auto-apply | ask each time |
+| `full-auto` | auto-apply | auto-run |
+
+### Settings
+
+```bash
+weio config                      # show all settings
+weio config approval auto-edit   # set a value
+weio config model pro            # auto | low | mid | pro
+weio config max_steps 40
+```
+
+Settings live in `~/.weio/settings.json`. The agent uses the most capable model
+your plan allows.
+
+### One-shot & other commands
+
+```bash
+# Run a coding task non-interactively (auto-applies edits; add --auto to also run commands):
+weio "add error handling to the fetch() in api.py"
+weio code "refactor db.py to async" --auto
+
+# Quick question (no file edits):
+weio ask "what does a 502 from nginx usually mean?"
+
+weio chat        # plain interactive chat
+weio usage       # tokens used / limits
+weio ping        # connectivity + key check
+```
+
+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 |
+|---|---|---|---|
+| API key | `--key` | `WEIO_API_KEY` | `~/.weio/config.json` |
+| API base | `--base` | `WEIO_BASE` | `~/.weio/config.json` |
+| Model | `--model` | — | — |
+
+Self-hosted / LAN gateway? Point at it with `--base http://HOST:8901/v1`.
+
+Output is billed against your Weio account usage.

weio_cli-0.5.0/README.md

@@ -0,0 +1,137 @@
+# weio-cli
+
+An agentic coding assistant that runs on your machine and routes inference
+through your [Weio](https://weio.ai) account.
+
+## Install
+
+```bash
+pip install weio-cli        # or: pipx install weio-cli
+```
+
+Requires Python 3.9+.
+
+## Authenticate
+
+```bash
+weio login            # opens your browser, sign in (incl. Google), key is created automatically
+```
+
+`weio login` starts a one-time local handshake, opens weio.ai in your browser to
+sign in, mints an API key for this device, and saves it to `~/.weio/config.json`.
+No copy-paste.
+
+Prefer to paste a key yourself? Generate one in **Settings → API & CLI** on
+weio.ai and:
+
+```bash
+weio login --no-browser     # paste your weio_sk_… key
+# or, per session:
+export WEIO_API_KEY="weio_sk_…"
+```
+
+Check what you're using:
+
+```bash
+weio usage            # tier, tokens used today, remaining, reset time
+```
+
+## Use
+
+### Interactive agent (default)
+
+Run `weio` with no arguments to start an autonomous coding agent in your terminal —
+like Claude Code / Codex. It reads files, searches, edits, and runs commands to
+complete your task, showing each step:
+
+```bash
+cd my-project
+weio
+```
+
+```
+weio › add a /health route to app.py and run the tests
+
+● Let me look at the app first.
+  📖 read_file app.py
+● Adding the route.
+  ✎ edit_file app.py
+  │ + @app.get("/health")
+  │ + def health(): return {"ok": True}
+  apply edit_file to app.py? [y/N] y
+● Verifying.
+  ❯ run_command pytest -q
+  │ exit=0  …  5 passed
+✔ Added /health and confirmed tests pass.
+```
+
+The agent uses tools: **read_file, list_dir, search, edit_file, write_file,
+run_command**. File paths are confined to the project directory.
+
+Slash commands: `/model <id>`, `/approval <mode>`, `/steps <n>`, `/settings`,
+`/undo`, `/clear`, `/cwd`, `/help`, `/exit`.
+
+### Approval modes
+
+Control how much the agent does without asking (`/approval` or `weio config approval`):
+
+| Mode | Edits | Shell commands |
+|---|---|---|
+| `suggest` (default) | ask each time | ask each time |
+| `auto-edit` | auto-apply | ask each time |
+| `full-auto` | auto-apply | auto-run |
+
+### Settings
+
+```bash
+weio config                      # show all settings
+weio config approval auto-edit   # set a value
+weio config model pro            # auto | low | mid | pro
+weio config max_steps 40
+```
+
+Settings live in `~/.weio/settings.json`. The agent uses the most capable model
+your plan allows.
+
+### One-shot & other commands
+
+```bash
+# Run a coding task non-interactively (auto-applies edits; add --auto to also run commands):
+weio "add error handling to the fetch() in api.py"
+weio code "refactor db.py to async" --auto
+
+# Quick question (no file edits):
+weio ask "what does a 502 from nginx usually mean?"
+
+weio chat        # plain interactive chat
+weio usage       # tokens used / limits
+weio ping        # connectivity + key check
+```
+
+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 |
+|---|---|---|---|
+| API key | `--key` | `WEIO_API_KEY` | `~/.weio/config.json` |
+| API base | `--base` | `WEIO_BASE` | `~/.weio/config.json` |
+| Model | `--model` | — | — |
+
+Self-hosted / LAN gateway? Point at it with `--base http://HOST:8901/v1`.
+
+Output is billed against your Weio account usage.

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

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "weio-cli"
-version = "0.3.0"
+version = "0.5.0"
 description = "Weio — an agentic coding assistant that routes inference through your Weio account."
 readme = "README.md"
 requires-python = ">=3.9"

{weio_cli-0.3.0 → weio_cli-0.5.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.3.0"
+__version__ = "0.5.0"

weio_cli-0.5.0/src/weio_cli/agent.py

@@ -0,0 +1,237 @@
+"""The Weio coding agent: an autonomous tool-use loop, like Claude Code / Codex.
+
+The model works step by step, emitting tool calls as fenced JSON ```action blocks.
+The agent executes them (gated by the approval mode), feeds back observations, and
+loops until the model calls `finish` or the step budget is exhausted.
+
+UI is injected via callbacks so the TUI and one-shot runner share this engine.
+"""
+from __future__ import annotations
+
+import json
+import re
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Callable, Optional
+
+from . import tools
+from .client import WeioClient, WeioError
+from .tools import ToolResult
+
+_FENCE_RE = re.compile(r"```(?:action|json)?\s*\n(.*?)```", re.DOTALL)
+_BARE_RE = re.compile(r'\{[^{}]*"tool"\s*:\s*"[a-z_]+".*?\}', re.DOTALL)
+
+READONLY_TOOLS = {"read_file", "list_dir", "search"}
+WRITE_TOOLS = {"write_file", "edit_file"}
+ALL_TOOLS = READONLY_TOOLS | WRITE_TOOLS | {"run_command", "finish"}
+
+
+def system_prompt(root: Path) -> str:
+    return f"""You are Weio, an autonomous coding agent working in the user's project directory:
+{root}
+
+You complete the user's task by using TOOLS, one step at a time. On each turn, briefly
+state what you are about to do (one or two sentences), then emit one or more tool calls
+as fenced JSON blocks exactly like this:
+
+```action
+{{"tool": "read_file", "args": {{"path": "src/app.py"}}}}
+```
+
+TOOLS:
+- read_file   {{"path": "..."}}                      read a file
+- list_dir    {{"path": "."}}                        list a directory
+- search      {{"query": "...", "path": "."}}        search file contents
+- write_file  {{"path": "...", "content": "..."}}    create/overwrite a file
+- edit_file   {{"path": "...", "search": "...", "replace": "..."}}  replace an exact snippet
+- run_command {{"command": "..."}}                   run a shell command in the project
+- finish      {{"summary": "..."}}                   call when the task is fully done
+
+RULES:
+- Explore before you edit: read_file / list_dir / search to understand the code first.
+- Take ONE logical step, then STOP and wait for the OBSERVATIONS before the next step.
+- edit_file "search" must match the current file contents EXACTLY (whitespace included).
+- Prefer edit_file for small changes; write_file for new files or full rewrites.
+- After making changes, verify (e.g. run tests or the file) when reasonable.
+- When the task is complete, call finish with a short summary. Never call finish early.
+- DO NOT just describe what you would do — emit the ```action block and DO it now.
+- Every reply must contain exactly one ```action block (until you call finish).
+
+EXAMPLE turn:
+Let me look at the file before changing it.
+```action
+{{"tool": "read_file", "args": {{"path": "math_utils.py"}}}}
+```"""
+
+
+@dataclass
+class Callbacks:
+    on_text: Callable[[str], None]                       # model narration
+    on_action: Callable[[str, dict], None]               # about to run a tool
+    on_result: Callable[[str, ToolResult], None]         # tool finished
+    approve: Callable[[str, dict, Optional[ToolResult]], bool]  # ask user (writes/cmds)
+    on_status: Callable[[str], None]                     # spinner/status text
+    on_finish: Callable[[str], None]                     # final summary
+
+
+def parse_actions(text: str) -> list[dict]:
+    """Extract tool calls. Accepts ```action / ```json fences, and bare JSON
+    objects containing a "tool" key (robust to weaker models' formatting)."""
+    actions = []
+    seen = set()
+    for m in _FENCE_RE.finditer(text):
+        raw = m.group(1).strip()
+        try:
+            obj = json.loads(raw)
+        except json.JSONDecodeError:
+            continue
+        if isinstance(obj, dict) and "tool" in obj:
+            key = json.dumps(obj, sort_keys=True)
+            if key not in seen:
+                seen.add(key)
+                actions.append(obj)
+    if not actions:
+        for m in _BARE_RE.finditer(text):
+            try:
+                obj = json.loads(m.group(0))
+            except json.JSONDecodeError:
+                continue
+            if isinstance(obj, dict) and "tool" in obj:
+                key = json.dumps(obj, sort_keys=True)
+                if key not in seen:
+                    seen.add(key)
+                    actions.append(obj)
+    return actions
+
+
+def strip_actions(text: str) -> str:
+    return _BARE_RE.sub("", _FENCE_RE.sub("", text)).strip()
+
+
+class Agent:
+    def __init__(self, client: WeioClient, root: Path, settings: dict, cb: Callbacks):
+        self.client = client
+        self.root = root
+        self.settings = settings
+        self.cb = cb
+        self.messages: list[dict] = [{"role": "system", "content": system_prompt(root)}]
+        self.approval = settings.get("approval", "suggest")
+        self.max_steps = int(settings.get("max_steps", 25))
+        self.max_tokens = int(settings.get("max_tokens", 4096))
+
+    # -- model call --
+    def _complete(self) -> str:
+        return self.client.chat(self.messages, max_tokens=self.max_tokens, temperature=0.1)
+
+    # -- approval policy --
+    def _needs_approval(self, tool: str) -> bool:
+        if self.approval == "full-auto":
+            return False
+        if tool in WRITE_TOOLS:
+            return self.approval == "suggest"
+        if tool == "run_command":
+            return True  # commands always confirmed unless full-auto
+        return False
+
+    # -- execute one tool, return observation string --
+    def _execute(self, tool: str, args: dict) -> str:
+        self.cb.on_action(tool, args)
+
+        if tool == "read_file":
+            r = tools.read_file(self.root, args.get("path", ""))
+        elif tool == "list_dir":
+            r = tools.list_dir(self.root, args.get("path", "."))
+        elif tool == "search":
+            r = tools.search_files(self.root, args.get("query", ""), args.get("path", "."))
+        elif tool == "write_file":
+            r = tools.write_file(self.root, args.get("path", ""), args.get("content", ""))
+            r = self._maybe_commit(tool, args, r)
+        elif tool == "edit_file":
+            r = tools.edit_file(self.root, args.get("path", ""),
+                                args.get("search", ""), args.get("replace", ""))
+            r = self._maybe_commit(tool, args, r)
+        elif tool == "run_command":
+            cmd = args.get("command", "")
+            if self._needs_approval(tool) and not self.cb.approve(tool, args, None):
+                r = ToolResult(False, "Command declined by user.", display=f"$ {cmd} (declined)")
+            else:
+                r = tools.run_command(self.root, cmd)
+        else:
+            r = ToolResult(False, f"Unknown tool: {tool}")
+
+        self.cb.on_result(tool, r)
+        return f"[{tool} {args.get('path') or args.get('command') or args.get('query') or ''}]\n{r.output}"
+
+    def _maybe_commit(self, tool: str, args: dict, r: ToolResult) -> ToolResult:
+        if not r.ok:
+            return r
+        if self._needs_approval(tool) and not self.cb.approve(tool, args, r):
+            return ToolResult(False, f"{tool} on {r.path} declined by user.",
+                              display=f"{tool} {r.path} (declined)")
+        if tools.commit_write(self.root, r.path, r.new_text):
+            return r
+        return ToolResult(False, f"Failed to write {r.path}")
+
+    # -- main loop --
+    _CLAIM_WORDS = ("added", "created", "edited", "wrote", "updated", "modified",
+                    "implemented", "changed", "inserted", "removed", "deleted")
+
+    def run_task(self, task: str) -> str:
+        self.messages.append({"role": "user", "content": task})
+        nudges = 0
+        for step in range(self.max_steps):
+            self.cb.on_status("thinking")
+            try:
+                response = self._complete()
+            except WeioError as e:
+                self.cb.on_text(f"[error] {e}")
+                return f"error: {e}"
+
+            narration = strip_actions(response)
+            if narration:
+                self.cb.on_text(narration)
+
+            actions = parse_actions(response)
+            self.messages.append({"role": "assistant", "content": response})
+
+            if not actions:
+                # The model replied without a tool call. If it sounds like it
+                # claimed to make a change (but didn't actually act), push back
+                # hard. Allow up to 2 nudges before accepting the reply as final.
+                claims_edit = any(w in narration.lower() for w in self._CLAIM_WORDS)
+                if nudges < 2:
+                    nudges += 1
+                    msg = ("You did NOT emit a tool call — nothing changed on disk. "
+                           "Nothing happens until you emit a ```action block. "
+                           "If you intended to edit a file, emit the edit_file (or write_file) "
+                           "action now with the exact content. Otherwise call finish.")
+                    if not claims_edit:
+                        msg = ("Take the next step now as a ```action block, "
+                               "or call finish if the task is already complete.")
+                    self.messages.append({"role": "user", "content": msg})
+                    continue
+                self.cb.on_finish(narration or "(done)")
+                return narration
+            nudges = 0
+
+            observations = []
+            finished = None
+            for act in actions:
+                tool = act.get("tool")
+                args = act.get("args", {}) if isinstance(act.get("args"), dict) else {}
+                if tool == "finish":
+                    finished = args.get("summary", "Done.")
+                    break
+                if tool not in ALL_TOOLS:
+                    observations.append(f"[{tool}] Unknown tool. Use only the listed tools.")
+                    continue
+                observations.append(self._execute(tool, args))
+
+            if finished is not None:
+                self.cb.on_finish(finished)
+                return finished
+
+            self.messages.append({"role": "user", "content": "OBSERVATIONS:\n" + "\n\n".join(observations)})
+
+        self.cb.on_finish("Reached the step limit before finishing. Re-run to continue.")
+        return "step-limit"

weio_cli-0.5.0/src/weio_cli/browser_login.py

@@ -0,0 +1,88 @@
+"""Browser-based login: open Weio in the browser, sign in (incl. Google), and
+receive a freshly-minted API key on a local loopback server. No manual key paste.
+
+Standard OAuth-CLI loopback pattern (like gcloud / gh): we start a localhost
+server, open the browser to the Weio authorize page with our port + a random
+state, the page mints a key and redirects back to the loopback with it.
+"""
+from __future__ import annotations
+
+import http.server
+import secrets
+import socketserver
+import sys
+import time
+import urllib.parse
+import webbrowser
+from typing import Optional
+
+
+def _web_base_from_api(api_base: str) -> str:
+    """https://weio.ai/v1 -> https://weio.ai"""
+    b = (api_base or "").rstrip("/")
+    if b.endswith("/v1"):
+        b = b[:-3]
+    return b.rstrip("/")
+
+
+_DONE_HTML = (
+    b"<!doctype html><html><head><meta charset='utf-8'><title>Weio CLI</title></head>"
+    b"<body style='font-family:-apple-system,Segoe UI,sans-serif;background:#0d1117;"
+    b"color:#e6edf3;display:flex;align-items:center;justify-content:center;height:100vh;margin:0'>"
+    b"<div style='text-align:center'><h2 style='color:#3fb950'>&#10003; Weio CLI authorized</h2>"
+    b"<p>You can close this tab and return to your terminal.</p></div></body></html>"
+)
+_FAIL_HTML = (
+    b"<!doctype html><html><body style='font-family:sans-serif'>"
+    b"<h2>Authorization failed.</h2><p>Please run <code>weio login</code> again.</p></body></html>"
+)
+
+
+def browser_login(api_base: str, timeout: float = 180.0) -> Optional[str]:
+    """Open the browser and return the minted API key, or None on failure/timeout."""
+    state = secrets.token_urlsafe(16)
+    result: dict = {}
+
+    class Handler(http.server.BaseHTTPRequestHandler):
+        def do_GET(self):  # noqa: N802
+            params = urllib.parse.parse_qs(urllib.parse.urlparse(self.path).query)
+            key = (params.get("key") or [None])[0]
+            st = (params.get("state") or [None])[0]
+            ok = bool(key) and st == state
+            self.send_response(200)
+            self.send_header("Content-Type", "text/html; charset=utf-8")
+            self.end_headers()
+            self.wfile.write(_DONE_HTML if ok else _FAIL_HTML)
+            if ok:
+                result["key"] = key
+
+        def log_message(self, *args):  # silence
+            pass
+
+    try:
+        httpd = socketserver.TCPServer(("127.0.0.1", 0), Handler)
+    except OSError as e:
+        print(f"Could not start local auth server: {e}", file=sys.stderr)
+        return None
+    httpd.timeout = 1
+    port = httpd.server_address[1]
+    auth_url = (f"{_web_base_from_api(api_base)}/cli/auth"
+                f"?port={port}&state={urllib.parse.quote(state)}")
+
+    print("Opening your browser to sign in to Weio…")
+    print(f"  {auth_url}")
+    print("  (If it doesn't open, copy that URL into your browser.)")
+    try:
+        webbrowser.open(auth_url)
+    except Exception:
+        pass
+
+    deadline = time.time() + timeout
+    try:
+        while "key" not in result and time.time() < deadline:
+            httpd.handle_request()
+    except KeyboardInterrupt:
+        pass
+    finally:
+        httpd.server_close()
+    return result.get("key")