weio-cli 0.1.0__tar.gz

weio_cli-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 We I/O Labs
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

weio_cli-0.1.0/PKG-INFO

@@ -0,0 +1,77 @@
+Metadata-Version: 2.4
+Name: weio-cli
+Version: 0.1.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
+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
+
+Generate an API key in **Settings → API & CLI** on weio.ai, then:
+
+```bash
+weio login                  # paste your weio_sk_… key (saved to ~/.weio/config.json)
+# or, per-session:
+export WEIO_API_KEY="weio_sk_…"
+```
+
+## Use
+
+```bash
+# Run a coding task in the current directory (reads & edits files):
+weio "add error handling to the fetch() in api.py"
+
+# Add specific files to the context:
+weio code "refactor to async" -f server.py -f db.py
+
+# One-shot question (no file edits):
+weio ask "what does a 502 from nginx usually mean?"
+
+# Interactive chat:
+weio chat
+
+# Check connectivity and your key:
+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.
+
+## 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.1.0/README.md

@@ -0,0 +1,56 @@
+# 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
+
+Generate an API key in **Settings → API & CLI** on weio.ai, then:
+
+```bash
+weio login                  # paste your weio_sk_… key (saved to ~/.weio/config.json)
+# or, per-session:
+export WEIO_API_KEY="weio_sk_…"
+```
+
+## Use
+
+```bash
+# Run a coding task in the current directory (reads & edits files):
+weio "add error handling to the fetch() in api.py"
+
+# Add specific files to the context:
+weio code "refactor to async" -f server.py -f db.py
+
+# One-shot question (no file edits):
+weio ask "what does a 502 from nginx usually mean?"
+
+# Interactive chat:
+weio chat
+
+# Check connectivity and your key:
+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.
+
+## 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.1.0/pyproject.toml

@@ -0,0 +1,35 @@
+[build-system]
+requires = ["setuptools>=68", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "weio-cli"
+version = "0.1.0"
+description = "Weio — an agentic coding assistant that routes inference through your Weio account."
+readme = "README.md"
+requires-python = ">=3.9"
+license = { text = "MIT" }
+authors = [{ name = "We I/O Labs" }]
+keywords = ["weio", "ai", "cli", "coding-assistant", "llm"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Environment :: Console",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Topic :: Software Development :: Code Generators",
+]
+dependencies = ["httpx>=0.24"]
+
+[project.urls]
+Homepage = "https://weio.ai"
+Documentation = "https://weio.ai/support"
+
+[project.scripts]
+weio = "weio_cli.cli:main"
+
+[tool.setuptools]
+package-dir = { "" = "src" }
+
+[tool.setuptools.packages.find]
+where = ["src"]

weio_cli-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

weio_cli-0.1.0/src/weio_cli/__init__.py

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

weio_cli-0.1.0/src/weio_cli/__main__.py

@@ -0,0 +1,6 @@
+import sys
+
+from .cli import main
+
+if __name__ == "__main__":
+    sys.exit(main())

weio_cli-0.1.0/src/weio_cli/cli.py

@@ -0,0 +1,273 @@
+"""weio — command-line entry point.
+
+Commands:
+  weio login                 Save your API key (and optional --base)
+  weio "do X"                Run a coding task in the current directory (default)
+  weio code "do X" [-f ...]  Same, explicit; -f adds files to the context
+  weio ask "question"        One-shot chat answer (no file edits)
+  weio chat                  Interactive chat session
+  weio ping                  Check connectivity + key
+"""
+from __future__ import annotations
+
+import argparse
+import sys
+from pathlib import Path
+
+from . import __version__, config
+from .client import WeioClient, WeioError
+from . import coder
+
+
+def _make_client(args) -> WeioClient:
+    key = config.resolve_key(getattr(args, "key", None))
+    base = config.resolve_base(getattr(args, "base", None))
+    model = getattr(args, "model", None) or "auto"
+    return WeioClient(key, base, model=model)
+
+
+def _max_tokens(args) -> int:
+    return int(getattr(args, "max_tokens", 4096) or 4096)
+
+
+def _c(text: str, code: str) -> str:
+    if not sys.stdout.isatty():
+        return text
+    return f"\033[{code}m{text}\033[0m"
+
+
+# --------------------------------------------------------------------------- #
+# Commands
+# --------------------------------------------------------------------------- #
+
+def cmd_login(args) -> int:
+    cli_key = getattr(args, "key", None)
+    cli_base = getattr(args, "base", None)
+    key = cli_key or input("Weio API key (weio_sk_…): ").strip()
+    if not key:
+        print("No key provided.", file=sys.stderr)
+        return 2
+    path = config.save(key=key, base=cli_base)
+    # Validate
+    try:
+        client = WeioClient(key, config.resolve_base(cli_base))
+        ok = client.ping()
+    except WeioError:
+        ok = False
+    print(f"Saved credentials to {path}")
+    print("Connection check:", _c("OK", "32") if ok else _c("could not verify (saved anyway)", "33"))
+    return 0
+
+
+def cmd_ping(args) -> int:
+    try:
+        client = _make_client(args)
+    except WeioError as e:
+        print(_c(str(e), "31"), file=sys.stderr)
+        return 2
+    ok = client.ping()
+    print(f"base: {client.base}")
+    print("status:", _c("reachable, key valid", "32") if ok else _c("unreachable or invalid key", "31"))
+    return 0 if ok else 1
+
+
+def cmd_ask(args) -> int:
+    try:
+        client = _make_client(args)
+    except WeioError as e:
+        print(_c(str(e), "31"), file=sys.stderr)
+        return 2
+    messages = [{"role": "user", "content": args.message}]
+    try:
+        if args.no_stream:
+            print(client.chat(messages, max_tokens=_max_tokens(args)))
+        else:
+            for delta in client.chat_stream(messages, max_tokens=_max_tokens(args)):
+                sys.stdout.write(delta)
+                sys.stdout.flush()
+            print()
+    except WeioError as e:
+        print("\n" + _c(str(e), "31"), file=sys.stderr)
+        return 1
+    return 0
+
+
+def cmd_chat(args) -> int:
+    try:
+        client = _make_client(args)
+    except WeioError as e:
+        print(_c(str(e), "31"), file=sys.stderr)
+        return 2
+    print(_c("Weio interactive chat.", "36"), "Ctrl-C or 'exit' to quit.\n")
+    history: list[dict] = []
+    while True:
+        try:
+            q = input(_c("you> ", "36")).strip()
+        except (EOFError, KeyboardInterrupt):
+            print()
+            break
+        if not q:
+            continue
+        if q in ("exit", "quit"):
+            break
+        history.append({"role": "user", "content": q})
+        sys.stdout.write(_c("weio> ", "32"))
+        sys.stdout.flush()
+        acc = ""
+        try:
+            for delta in client.chat_stream(history, max_tokens=_max_tokens(args)):
+                acc += delta
+                sys.stdout.write(delta)
+                sys.stdout.flush()
+            print("\n")
+        except WeioError as e:
+            print("\n" + _c(str(e), "31"), file=sys.stderr)
+            history.pop()
+            continue
+        history.append({"role": "assistant", "content": acc})
+    return 0
+
+
+def cmd_code(args) -> int:
+    try:
+        client = _make_client(args)
+    except WeioError as e:
+        print(_c(str(e), "31"), file=sys.stderr)
+        return 2
+    root = Path(args.dir).resolve()
+    if not root.is_dir():
+        print(_c(f"Not a directory: {root}", "31"), file=sys.stderr)
+        return 2
+
+    print(_c(f"weio coding in {root}", "36"))
+    print("Thinking…", flush=True)
+    try:
+        raw, edits = coder.run_coding_task(
+            client, args.message, root=root, files=args.file or [], max_tokens=_max_tokens(args)
+        )
+    except WeioError as e:
+        print(_c(str(e), "31"), file=sys.stderr)
+        return 1
+
+    if not edits:
+        # No edits — show the model's reply (it may be asking for files or explaining)
+        print(raw)
+        return 0
+
+    # Apply edits (preview + confirm unless --yes)
+    results, errors = [], []
+    for e in edits:
+        res, err = coder.apply_edit(e, root)
+        if err:
+            errors.append(err)
+        elif res:
+            results.append(res)
+
+    for res in results:
+        tag = _c("NEW", "32") if res.created else _c("EDIT", "33")
+        print(f"\n{tag} {res.path}")
+        if res.created:
+            preview = res.new_text if len(res.new_text) < 1500 else res.new_text[:1500] + "\n… [truncated preview]"
+            print(preview)
+        else:
+            print(coder.unified_diff(res.path, res.old_text, res.new_text) or "(no textual diff)")
+
+    for err in errors:
+        print(_c("SKIP " + err, "31"))
+
+    if not results:
+        print(_c("\nNo applicable edits.", "33"))
+        return 1
+
+    if not args.yes:
+        try:
+            ans = input(_c(f"\nApply {len(results)} change(s)? [y/N] ", "36")).strip().lower()
+        except (EOFError, KeyboardInterrupt):
+            print()
+            ans = "n"
+        if ans not in ("y", "yes"):
+            print("Aborted. No files written.")
+            return 0
+
+    written = 0
+    for res in results:
+        fp = root / res.path
+        fp.parent.mkdir(parents=True, exist_ok=True)
+        fp.write_text(res.new_text, encoding="utf-8")
+        written += 1
+    print(_c(f"\nApplied {written} change(s).", "32"))
+    return 0
+
+
+# --------------------------------------------------------------------------- #
+# Parser
+# --------------------------------------------------------------------------- #
+
+def build_parser() -> argparse.ArgumentParser:
+    # Shared auth/model flags — accepted both before AND after the subcommand,
+    # so `weio --key X ask "q"` and `weio ask "q" --key X` both work.
+    common = argparse.ArgumentParser(add_help=False)
+    # SUPPRESS defaults so a flag given before the subcommand isn't clobbered by
+    # the subparser's default (argparse parents + subparsers share dests).
+    common.add_argument("--key", "-k", default=argparse.SUPPRESS,
+                        help="API key (or set WEIO_API_KEY / run `weio login`)")
+    common.add_argument("--base", default=argparse.SUPPRESS,
+                        help="API base URL (default https://api.weio.ai/v1)")
+    common.add_argument("--model", "-m", default=argparse.SUPPRESS, help="Model id (default: auto)")
+    common.add_argument("--max-tokens", type=int, default=argparse.SUPPRESS, help="Max output tokens")
+
+    p = argparse.ArgumentParser(
+        prog="weio",
+        parents=[common],
+        description="Weio — an agentic coding assistant that routes inference through your Weio account.",
+    )
+    p.add_argument("--version", action="version", version=f"weio-cli {__version__}")
+
+    sub = p.add_subparsers(dest="command")
+
+    sp = sub.add_parser("login", parents=[common], help="Save your API key")
+    sp.set_defaults(func=cmd_login)
+
+    sp = sub.add_parser("ping", parents=[common], help="Check connectivity and key")
+    sp.set_defaults(func=cmd_ping)
+
+    sp = sub.add_parser("ask", parents=[common], help="One-shot question (no file edits)")
+    sp.add_argument("message")
+    sp.add_argument("--no-stream", action="store_true")
+    sp.set_defaults(func=cmd_ask)
+
+    sp = sub.add_parser("chat", parents=[common], help="Interactive chat")
+    sp.set_defaults(func=cmd_chat)
+
+    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)")
+    sp.add_argument("--dir", "-C", default=".", help="Project directory (default: cwd)")
+    sp.add_argument("--yes", "-y", action="store_true", help="Apply edits without confirmation")
+    sp.set_defaults(func=cmd_code)
+
+    return p
+
+
+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("-"):
+        argv = ["code", *argv]
+
+    args = parser.parse_args(argv)
+    if not getattr(args, "command", None):
+        parser.print_help()
+        return 1
+    try:
+        return args.func(args)
+    except KeyboardInterrupt:
+        print()
+        return 130
+
+
+if __name__ == "__main__":
+    sys.exit(main())

weio_cli-0.1.0/src/weio_cli/client.py

@@ -0,0 +1,97 @@
+"""Thin client for the Weio OpenAI-compatible gateway."""
+from __future__ import annotations
+
+import json
+from typing import Iterator, Optional
+
+try:
+    import httpx
+except ImportError:  # pragma: no cover
+    raise SystemExit("weio-cli requires httpx. Install with: pip install httpx")
+
+from . import __version__
+
+
+class WeioError(RuntimeError):
+    pass
+
+
+class WeioClient:
+    def __init__(self, api_key: str, base: str, *, model: str = "auto", timeout: float = 180.0):
+        if not api_key:
+            raise WeioError("No API key. Run `weio login` or pass --key / set WEIO_API_KEY.")
+        self.api_key = api_key
+        self.base = base.rstrip("/")
+        self.model = model
+        self.timeout = timeout
+
+    def _headers(self) -> dict:
+        return {
+            "Authorization": f"Bearer {self.api_key}",
+            "Content-Type": "application/json",
+            "User-Agent": f"weio-cli/{__version__}",
+        }
+
+    def chat(self, messages: list[dict], *, max_tokens: int = 2048,
+             temperature: float = 0.7, model: Optional[str] = None) -> str:
+        """Non-streaming completion. Returns the assistant text."""
+        payload = {
+            "model": model or self.model,
+            "messages": messages,
+            "max_tokens": max_tokens,
+            "temperature": temperature,
+        }
+        try:
+            r = httpx.post(f"{self.base}/chat/completions", headers=self._headers(),
+                           json=payload, timeout=self.timeout)
+        except httpx.HTTPError as e:
+            raise WeioError(f"Network error talking to {self.base}: {e}") from e
+        if r.status_code == 401:
+            raise WeioError("Authentication failed (401). Check your API key.")
+        if r.status_code == 402 or r.status_code == 429:
+            raise WeioError(f"Usage limit or quota reached ({r.status_code}). {r.text[:200]}")
+        if r.status_code >= 400:
+            raise WeioError(f"Gateway error {r.status_code}: {r.text[:300]}")
+        try:
+            return r.json()["choices"][0]["message"]["content"]
+        except (KeyError, IndexError, json.JSONDecodeError) as e:
+            raise WeioError(f"Unexpected response shape: {r.text[:300]}") from e
+
+    def chat_stream(self, messages: list[dict], *, max_tokens: int = 2048,
+                    temperature: float = 0.7, model: Optional[str] = None) -> Iterator[str]:
+        """Streaming completion. Yields text deltas. Falls back to non-stream on error."""
+        payload = {
+            "model": model or self.model,
+            "messages": messages,
+            "max_tokens": max_tokens,
+            "temperature": temperature,
+            "stream": True,
+        }
+        try:
+            with httpx.stream("POST", f"{self.base}/chat/completions",
+                              headers=self._headers(), json=payload, timeout=self.timeout) as r:
+                if r.status_code >= 400:
+                    body = r.read().decode("utf-8", "replace")
+                    raise WeioError(f"Gateway error {r.status_code}: {body[:300]}")
+                for line in r.iter_lines():
+                    if not line or not line.startswith("data:"):
+                        continue
+                    data = line[5:].strip()
+                    if data == "[DONE]":
+                        break
+                    try:
+                        delta = json.loads(data)["choices"][0].get("delta", {}).get("content")
+                        if delta:
+                            yield delta
+                    except (KeyError, IndexError, json.JSONDecodeError):
+                        continue
+        except httpx.HTTPError as e:
+            raise WeioError(f"Network error talking to {self.base}: {e}") from e
+
+    def ping(self) -> bool:
+        """Check the gateway is reachable and the key is valid (GET /models)."""
+        try:
+            r = httpx.get(f"{self.base}/models", headers=self._headers(), timeout=15.0)
+            return r.status_code == 200
+        except httpx.HTTPError:
+            return False

weio_cli-0.1.0/src/weio_cli/coder.py

@@ -0,0 +1,160 @@
+"""Agentic coding: gather file context, ask the model for edits, apply them.
+
+Edit protocol (the model is instructed to emit one or more blocks):
+
+    ```edit path/to/file.ext
+    <<<<<<< SEARCH
+    exact existing lines to find (empty for a new file)
+    =======
+    replacement lines
+    >>>>>>> REPLACE
+    ```
+
+Multiple SEARCH/REPLACE pairs may appear under a single path. New files use an
+empty SEARCH section.
+"""
+from __future__ import annotations
+
+import difflib
+import re
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Optional
+
+from .client import WeioClient, WeioError
+
+CODER_SYSTEM = """You are Weio, an expert pair-programmer operating as a command-line coding agent on the user's machine.
+
+You modify code by emitting EDIT BLOCKS. For every file you change, output a fenced block:
+
+```edit relative/path/to/file.ext
+<<<<<<< SEARCH
+<exact lines that currently exist in the file>
+=======
+<the replacement lines>
+>>>>>>> REPLACE
+```
+
+Rules:
+- The SEARCH text must match the current file content EXACTLY (whitespace included).
+- To create a NEW file, leave the SEARCH section empty and put the full contents in REPLACE.
+- Keep edits minimal and focused; you may emit several blocks (including several per file).
+- Only touch files needed for the task. Do not invent file contents you were not shown.
+- After the edit blocks, add a one-paragraph summary of what you changed and why.
+- If you need to see a file that was not provided, say so explicitly instead of guessing."""
+
+_BLOCK_RE = re.compile(
+    r"```edit[ \t]+(?P<path>[^\n`]+)\n(?P<body>.*?)```",
+    re.DOTALL,
+)
+_SR_RE = re.compile(
+    r"<<<<<<< SEARCH\n(?P<search>.*?)\n?=======\n(?P<replace>.*?)\n?>>>>>>> REPLACE",
+    re.DOTALL,
+)
+
+
+@dataclass
+class Edit:
+    path: str
+    search: str
+    replace: str
+
+
+@dataclass
+class FileResult:
+    path: str
+    created: bool = False
+    applied: int = 0
+    failed: list[str] = field(default_factory=list)
+    old_text: str = ""
+    new_text: str = ""
+
+
+def parse_edits(text: str) -> list[Edit]:
+    edits: list[Edit] = []
+    for m in _BLOCK_RE.finditer(text):
+        path = m.group("path").strip()
+        body = m.group("body")
+        pairs = list(_SR_RE.finditer(body))
+        if not pairs:
+            continue
+        for sr in pairs:
+            edits.append(Edit(path=path, search=sr.group("search"), replace=sr.group("replace")))
+    return edits
+
+
+def gather_context(instruction: str, explicit_files: list[str], root: Path,
+                   max_bytes: int = 60_000) -> tuple[str, list[str]]:
+    """Collect file contents for the prompt. Returns (context_text, included_paths)."""
+    candidates: list[str] = list(explicit_files)
+    # Auto-detect path-like tokens in the instruction (e.g. src/app.py)
+    for tok in re.findall(r"[\w./-]+\.\w{1,6}", instruction):
+        if tok not in candidates and (root / tok).is_file():
+            candidates.append(tok)
+
+    included, blocks, total = [], [], 0
+    for rel in candidates:
+        fp = root / rel
+        if not fp.is_file():
+            continue
+        try:
+            content = fp.read_text(encoding="utf-8")
+        except (UnicodeDecodeError, OSError):
+            continue
+        if total + len(content) > max_bytes:
+            content = content[: max(0, max_bytes - total)] + "\n... [truncated]"
+        blocks.append(f"=== FILE: {rel} ===\n{content}")
+        included.append(rel)
+        total += len(content)
+        if total >= max_bytes:
+            break
+
+    if not blocks:
+        return "", []
+    return "\n\n".join(blocks), included
+
+
+def apply_edit(edit: Edit, root: Path) -> tuple[Optional[FileResult], Optional[str]]:
+    """Apply a single edit. Returns (result, error)."""
+    fp = root / edit.path
+    if edit.search.strip() == "":
+        # New file (or full overwrite if it somehow exists)
+        return FileResult(path=edit.path, created=not fp.exists(), applied=1,
+                          old_text="", new_text=edit.replace), None
+    if not fp.exists():
+        return None, f"{edit.path}: file not found for SEARCH/REPLACE"
+    try:
+        original = fp.read_text(encoding="utf-8")
+    except (UnicodeDecodeError, OSError) as e:
+        return None, f"{edit.path}: cannot read ({e})"
+    if edit.search not in original:
+        return None, f"{edit.path}: SEARCH block did not match current contents"
+    new_text = original.replace(edit.search, edit.replace, 1)
+    return FileResult(path=edit.path, created=False, applied=1,
+                      old_text=original, new_text=new_text), None
+
+
+def unified_diff(path: str, old: str, new: str) -> str:
+    diff = difflib.unified_diff(
+        old.splitlines(keepends=True), new.splitlines(keepends=True),
+        fromfile=f"a/{path}", tofile=f"b/{path}",
+    )
+    return "".join(diff)
+
+
+def run_coding_task(client: WeioClient, instruction: str, *, root: Path,
+                    files: list[str], max_tokens: int = 4096) -> tuple[str, list[Edit]]:
+    """Ask the model for edits. Returns (raw_response, parsed_edits)."""
+    context, included = gather_context(instruction, files, root)
+    user_parts = [f"TASK:\n{instruction}"]
+    if context:
+        user_parts.append(f"\nCURRENT FILES (for reference):\n{context}")
+    else:
+        user_parts.append("\n(No files were provided. If the task needs existing files, "
+                          "ask for them by path. For new files, emit edit blocks with an empty SEARCH.)")
+    messages = [
+        {"role": "system", "content": CODER_SYSTEM},
+        {"role": "user", "content": "\n".join(user_parts)},
+    ]
+    raw = client.chat(messages, max_tokens=max_tokens, temperature=0.1)
+    return raw, parse_edits(raw)

weio_cli-0.1.0/src/weio_cli/config.py

@@ -0,0 +1,55 @@
+"""Configuration: API key + base URL resolution and persistence.
+
+Resolution order (first hit wins):
+  1. Explicit --key / --base CLI flags
+  2. WEIO_API_KEY / WEIO_BASE environment variables
+  3. ~/.weio/config.json  (written by `weio login`)
+  4. Built-in default base
+"""
+from __future__ import annotations
+
+import json
+import os
+from pathlib import Path
+from typing import Optional
+
+DEFAULT_BASE = "https://api.weio.ai/v1"
+
+CONFIG_DIR = Path(os.environ.get("WEIO_CONFIG_DIR", str(Path.home() / ".weio")))
+CONFIG_FILE = CONFIG_DIR / "config.json"
+
+
+def _read_file() -> dict:
+    try:
+        return json.loads(CONFIG_FILE.read_text())
+    except Exception:
+        return {}
+
+
+def save(key: Optional[str] = None, base: Optional[str] = None) -> Path:
+    """Persist key/base to ~/.weio/config.json (0600)."""
+    data = _read_file()
+    if key is not None:
+        data["api_key"] = key
+    if base is not None:
+        data["base"] = base
+    CONFIG_DIR.mkdir(parents=True, exist_ok=True)
+    CONFIG_FILE.write_text(json.dumps(data, indent=2))
+    try:
+        CONFIG_FILE.chmod(0o600)
+    except Exception:
+        pass
+    return CONFIG_FILE
+
+
+def resolve_key(cli_key: Optional[str]) -> Optional[str]:
+    return cli_key or os.environ.get("WEIO_API_KEY") or _read_file().get("api_key")
+
+
+def resolve_base(cli_base: Optional[str]) -> str:
+    return (
+        cli_base
+        or os.environ.get("WEIO_BASE")
+        or _read_file().get("base")
+        or DEFAULT_BASE
+    )

weio_cli-0.1.0/src/weio_cli.egg-info/PKG-INFO

@@ -0,0 +1,77 @@
+Metadata-Version: 2.4
+Name: weio-cli
+Version: 0.1.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
+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
+
+Generate an API key in **Settings → API & CLI** on weio.ai, then:
+
+```bash
+weio login                  # paste your weio_sk_… key (saved to ~/.weio/config.json)
+# or, per-session:
+export WEIO_API_KEY="weio_sk_…"
+```
+
+## Use
+
+```bash
+# Run a coding task in the current directory (reads & edits files):
+weio "add error handling to the fetch() in api.py"
+
+# Add specific files to the context:
+weio code "refactor to async" -f server.py -f db.py
+
+# One-shot question (no file edits):
+weio ask "what does a 502 from nginx usually mean?"
+
+# Interactive chat:
+weio chat
+
+# Check connectivity and your key:
+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.
+
+## 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.1.0/src/weio_cli.egg-info/SOURCES.txt

@@ -0,0 +1,16 @@
+LICENSE
+README.md
+pyproject.toml
+src/weio_cli/__init__.py
+src/weio_cli/__main__.py
+src/weio_cli/cli.py
+src/weio_cli/client.py
+src/weio_cli/coder.py
+src/weio_cli/config.py
+src/weio_cli.egg-info/PKG-INFO
+src/weio_cli.egg-info/SOURCES.txt
+src/weio_cli.egg-info/dependency_links.txt
+src/weio_cli.egg-info/entry_points.txt
+src/weio_cli.egg-info/requires.txt
+src/weio_cli.egg-info/top_level.txt
+tests/test_coder.py

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

@@ -0,0 +1 @@
+

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

@@ -0,0 +1,2 @@
+[console_scripts]
+weio = weio_cli.cli:main

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

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

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

@@ -0,0 +1 @@
+weio_cli

weio_cli-0.1.0/tests/test_coder.py

@@ -0,0 +1,87 @@
+"""Unit tests for the edit-block parser and application logic."""
+import sys
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parents[1] / "src"))
+
+from weio_cli import coder  # noqa: E402
+
+
+def test_parse_single_edit():
+    text = """Here you go:
+```edit app.py
+<<<<<<< SEARCH
+def f():
+    return 1
+=======
+def f():
+    return 2
+>>>>>>> REPLACE
+```
+Done."""
+    edits = coder.parse_edits(text)
+    assert len(edits) == 1
+    assert edits[0].path == "app.py"
+    assert "return 1" in edits[0].search
+    assert "return 2" in edits[0].replace
+
+
+def test_parse_new_file_empty_search():
+    text = """```edit new.py
+<<<<<<< SEARCH
+=======
+print("hi")
+>>>>>>> REPLACE
+```"""
+    edits = coder.parse_edits(text)
+    assert len(edits) == 1
+    assert edits[0].search.strip() == ""
+    assert 'print("hi")' in edits[0].replace
+
+
+def test_parse_multiple_blocks():
+    text = """```edit a.py
+<<<<<<< SEARCH
+x = 1
+=======
+x = 2
+>>>>>>> REPLACE
+```
+```edit b.py
+<<<<<<< SEARCH
+y = 1
+=======
+y = 2
+>>>>>>> REPLACE
+```"""
+    edits = coder.parse_edits(text)
+    assert {e.path for e in edits} == {"a.py", "b.py"}
+
+
+def test_apply_edit_match(tmp_path):
+    fp = tmp_path / "m.py"
+    fp.write_text("a = 1\nb = 2\n")
+    e = coder.Edit(path="m.py", search="a = 1", replace="a = 99")
+    res, err = coder.apply_edit(e, tmp_path)
+    assert err is None
+    assert "a = 99" in res.new_text and "b = 2" in res.new_text
+
+
+def test_apply_edit_no_match(tmp_path):
+    fp = tmp_path / "m.py"
+    fp.write_text("a = 1\n")
+    e = coder.Edit(path="m.py", search="zzz", replace="qqq")
+    res, err = coder.apply_edit(e, tmp_path)
+    assert res is None and "did not match" in err
+
+
+def test_apply_new_file(tmp_path):
+    e = coder.Edit(path="brand_new.py", search="", replace="print('new')\n")
+    res, err = coder.apply_edit(e, tmp_path)
+    assert err is None and res.created is True
+    assert "print('new')" in res.new_text
+
+
+if __name__ == "__main__":
+    import subprocess
+    raise SystemExit(subprocess.call([sys.executable, "-m", "pytest", __file__, "-v"]))