opencode-py 0.1.0__py3-none-any.whl

opencode/_tools.py

@@ -0,0 +1,156 @@
+from __future__ import annotations
+
+import glob as glob_mod
+import os
+import subprocess
+import sys
+from typing import Any, Callable, Dict, List, Optional
+
+Permission = str
+PERMIT_ALLOW: Permission = "allow"
+PERMIT_ASK: Permission = "ask"
+PERMIT_DENY: Permission = "deny"
+
+DEFAULT_PERMISSIONS: Dict[str, Permission] = {
+    "bash": PERMIT_ASK,
+    "write": PERMIT_ALLOW,
+    "edit": PERMIT_ALLOW,
+    "read": PERMIT_ALLOW,
+    "glob": PERMIT_ALLOW,
+    "grep": PERMIT_ALLOW,
+}
+
+
+def _default_confirm(tool_name: str, tool_input: Dict[str, Any]) -> bool:
+    print(f"\n\033[33m[Tool] {tool_name}({tool_input!r})\033[0m")
+    answer = input("  Allow? [Y/n] ").strip().lower()
+    return answer not in ("n", "no")
+
+
+class ToolExecutor:
+    def __init__(
+        self,
+        permissions: Optional[Dict[str, Permission]] = None,
+        confirm: Optional[Callable[[str, Dict[str, Any]], bool]] = None,
+        workdir: Optional[str] = None,
+    ):
+        self._permissions = {**DEFAULT_PERMISSIONS, **(permissions or {})}
+        self._confirm = confirm or _default_confirm
+        self._workdir = workdir
+
+    def execute(self, tool_name: str, tool_input: Dict[str, Any]) -> Dict[str, Any]:
+        permit = self._permissions.get(tool_name, PERMIT_ALLOW)
+        if permit == PERMIT_DENY:
+            return {"error": f"Tool '{tool_name}' is denied by configuration"}
+        if permit == PERMIT_ASK:
+            allowed = self._confirm(tool_name, tool_input)
+            if not allowed:
+                return {"error": f"Tool '{tool_name}' was rejected by user"}
+
+        handler = self._handlers().get(tool_name)
+        if not handler:
+            return {"error": f"Unknown tool '{tool_name}'"}
+        return handler(tool_input)
+
+    def _handlers(self) -> Dict[str, Callable[[Dict[str, Any]], Dict[str, Any]]]:
+        return {
+            "bash": self._bash,
+            "write": self._write,
+            "edit": self._edit,
+            "read": self._read,
+            "glob": self._glob,
+            "grep": self._grep,
+        }
+
+    # ------------------------------------------------------------------
+    # Tool implementations
+    # ------------------------------------------------------------------
+
+    def _bash(self, inp: Dict[str, Any]) -> Dict[str, Any]:
+        command = inp.get("command", "")
+        timeout = inp.get("timeout", 30)
+        try:
+            result = subprocess.run(
+                command,
+                shell=True,
+                capture_output=True,
+                text=True,
+                timeout=timeout,
+                cwd=self._workdir,
+            )
+            return {
+                "exitStatus": result.returncode,
+                "stdout": result.stdout,
+                "stderr": result.stderr,
+            }
+        except subprocess.TimeoutExpired:
+            return {"exitStatus": -1, "stdout": "", "stderr": "Command timed out"}
+
+    def _write(self, inp: Dict[str, Any]) -> Dict[str, Any]:
+        path = inp.get("path", "")
+        content = inp.get("content", "")
+        full_path = os.path.join(self._workdir, path) if self._workdir else path
+        os.makedirs(os.path.dirname(os.path.abspath(full_path)), exist_ok=True)
+        with open(full_path, "w", encoding="utf-8") as f:
+            f.write(content)
+        return {"success": True, "path": path}
+
+    def _edit(self, inp: Dict[str, Any]) -> Dict[str, Any]:
+        path = inp.get("path", "")
+        old = inp.get("old", "")
+        new = inp.get("new", "")
+        full_path = os.path.join(self._workdir, path) if self._workdir else path
+        try:
+            with open(full_path, "r", encoding="utf-8") as f:
+                text = f.read()
+            if old not in text:
+                return {"error": "old string not found", "success": False}
+            text = text.replace(old, new, 1)
+            with open(full_path, "w", encoding="utf-8") as f:
+                f.write(text)
+            return {"success": True}
+        except FileNotFoundError:
+            return {"error": f"File not found: {path}", "success": False}
+
+    def _read(self, inp: Dict[str, Any]) -> Dict[str, Any]:
+        path = inp.get("path", "")
+        full_path = os.path.join(self._workdir, path) if self._workdir else path
+        try:
+            with open(full_path, "r", encoding="utf-8") as f:
+                content = f.read()
+            return {"content": content}
+        except FileNotFoundError:
+            return {"error": f"File not found: {path}"}
+
+    def _glob(self, inp: Dict[str, Any]) -> Dict[str, Any]:
+        pattern = inp.get("pattern", "")
+        full_pattern = os.path.join(self._workdir, pattern) if self._workdir else pattern
+        files = glob_mod.glob(full_pattern, recursive=True)
+        return {"files": files}
+
+    def _grep(self, inp: Dict[str, Any]) -> Dict[str, Any]:
+        pattern = inp.get("pattern", "")
+        search_path = inp.get("path", "")
+        if search_path:
+            full_path = os.path.join(self._workdir, search_path) if self._workdir else search_path
+        else:
+            full_path = self._workdir or "."
+        import re
+
+        results: List[Dict[str, Any]] = []
+        for root, dirs, files in os.walk(full_path):
+            dirs[:] = [d for d in dirs if not d.startswith(".") and d != "node_modules" and d != ".git"]
+            for fname in files:
+                fpath = os.path.join(root, fname)
+                try:
+                    with open(fpath, "r", encoding="utf-8", errors="ignore") as f:
+                        for lineno, line in enumerate(f, 1):
+                            if re.search(pattern, line):
+                                results.append({
+                                    "path": os.path.relpath(fpath, self._workdir) if self._workdir else fpath,
+                                    "line": lineno,
+                                    "content": line.rstrip(),
+                                })
+                except Exception:
+                    pass
+        return {"results": results}

opencode_py-0.1.0.dist-info/METADATA

@@ -0,0 +1,201 @@
+Metadata-Version: 2.4
+Name: opencode-py
+Version: 0.1.0
+Summary: Python SDK for Opencode — the open source AI coding agent
+Project-URL: Homepage, https://opencode.ai
+Project-URL: Repository, https://github.com/anomalyco/opencode
+Project-URL: Documentation, https://opencode.ai/docs
+Author-email: Anomaly <hello@opencode.ai>
+License: MIT
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Python: >=3.10
+Requires-Dist: httpx>=0.27.0
+Provides-Extra: dev
+Requires-Dist: build>=1.0; extra == 'dev'
+Requires-Dist: httpx>=0.27.0; extra == 'dev'
+Requires-Dist: pytest-asyncio>=0.21; extra == 'dev'
+Requires-Dist: pytest>=8.0; extra == 'dev'
+Requires-Dist: twine>=4.0; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# Opencode Python SDK
+
+Python SDK for [Opencode](https://opencode.ai) — the open source AI coding agent.
+
+```bash
+pip install opencode-py
+```
+
+## Quick start
+
+### One-shot (spawns server, asks, cleans up)
+
+```python
+from opencode import opencode
+
+answer = opencode("What is the capital of France?")
+print(answer)
+```
+
+### Context manager (recommended)
+
+```python
+from opencode import Opencode
+
+with Opencode() as ai:
+    answer = ai.ask("Explain dependency injection")
+    print(answer)
+```
+
+### Streaming
+
+```python
+with Opencode() as ai:
+    for chunk in ai.ask_stream("Write a Python function"):
+        print(chunk, end="")
+```
+
+### Conversations
+
+```python
+with Opencode() as ai:
+    session = ai.create_session()
+    msg1 = session.prompt("Suggest a project name")
+    print(f"AI: {msg1}")
+    msg2 = session.prompt("Now write a tagline for it")
+    print(f"AI: {msg2}")
+```
+
+### Multi-turn (keep mode)
+
+```python
+from opencode import opencode
+
+# keep=True — server and session stay alive between calls
+r1 = opencode("My name is Alice", keep=True)
+r2 = opencode("What's my name?", keep=True)   # remembers the conversation
+r3 = opencode("That's all", keep=False)        # keep=False closes the server
+```
+
+### Auto-tools (agentic tool execution)
+
+```python
+r = opencode("Create a file called hello.txt", auto_tools=True)
+```
+
+Available tools: `bash`, `write`, `edit`, `read`, `glob`, `grep`.
+
+By default, `bash` asks for permission in the console, all others run without prompting.
+
+Custom permissions via `Session.ask()`:
+
+```python
+from opencode import Opencode, ToolExecutor
+
+with Opencode() as ai:
+    session = ai.create_session()
+    msg = session.ask(
+        "Write test.py with print('hello')",
+        tool_executor=ToolExecutor(permissions={"write": "allow"}),
+    )
+```
+
+### Low-level API (any endpoint)
+
+```python
+with Opencode() as ai:
+    content = ai.client.file_read("src/main.py")
+    diff = ai.client.vcs_diff("HEAD~3")
+    config = ai.client.config_get()
+    session = ai.client.session_create()
+    ai.client.v2_session_prompt(session["id"], {"text": "Hello"})
+```
+
+### Web UI (zero dependencies)
+
+```bash
+python web/server.py
+# → open http://127.0.0.1:3000
+```
+
+Built-in HTTP server + proxy to `opencode serve` — no extra dependencies.
+
+### Interactive dialog
+
+```bash
+python live.py
+```
+
+Multi-turn dialog with `keep=True`, server cleaned up on exit via `atexit`.
+
+### Configuration
+
+```python
+with Opencode(
+    model="claude-sonnet-4-20250514",
+    directory="/path/to/project",
+    port=4096,
+) as ai:
+    ...
+```
+
+## Async API
+
+```python
+import asyncio
+from opencode import AsyncOpendcode
+
+async def main():
+    async with AsyncOpendcode() as ai:
+        answer = await ai.ask("Explain async/await in Python")
+        print(answer)
+
+asyncio.run(main())
+```
+
+### Async streaming
+
+```python
+async with AsyncOpendcode() as ai:
+    async for chunk in ai.ask_stream("Write a poem"):
+        print(chunk, end="")
+```
+
+### Async conversations
+
+```python
+async with AsyncOpendcode() as ai:
+    session = await ai.create_session()
+    msg1 = await session.prompt("Suggest a project name")
+    msg2 = await session.prompt("Now write a tagline for it")
+```
+
+### Async low-level client
+
+```python
+from opencode import AsyncOpendcodeClient
+
+async with AsyncOpendcodeClient() as client:
+    health = await client.health()
+    print(health)
+```
+
+## Development
+
+```bash
+# Install in editable mode
+pip install -e ".[dev]"
+
+# Run tests
+pytest
+
+# Build
+python -m build --wheel
+```

opencode_py-0.1.0.dist-info/RECORD

@@ -0,0 +1,17 @@
+opencode/__init__.py,sha256=q3odOwNB6lfK5PVg1jcGxx-pspYr5KVeL6XkNbhhrIw,1230
+opencode/__main__.py,sha256=RgEMXv19aTIrktpTlon0JnoiUcFD5Cyz5d7n1NREZLA,390
+opencode/_async_client.py,sha256=_AsfFNckUbs0QS49dWJAy7fZA8h-KEToLQa045GMCo8,22923
+opencode/_async_opencode.py,sha256=UJsevh4d9ijDdEyvJ1shc31XjSDQ7LqakLaK3fv42Es,8428
+opencode/_async_session.py,sha256=wAMOI2c8-qODi_CqDpkEkodl5M1vq3jz3QXbB7oHtd4,5708
+opencode/_binary.py,sha256=btfsHOPUc2iYQxYWl8BCgjBRK5_jQ2QVFrBQl-mp_so,3851
+opencode/_client.py,sha256=y-BA-W_7_dyy9fRPBa7sTp6Ut9IFRzZGV-VXF6RzTv8,21390
+opencode/_errors.py,sha256=G65WyH15Nbtmauzfi_8KpvsSwT5WsdyxwCeJYBBKpQQ,387
+opencode/_models.py,sha256=BGBF2jfkVPfVJqcUfcKw24JQUHmYv8QvYqxs-dyq82w,2543
+opencode/_opencode.py,sha256=gSzGoODCwlI9mO3Hcq6i09whTxW2YxM5yide1JjV8Cc,9364
+opencode/_process.py,sha256=gwF1tgWUENOMUniY2Out6RqKvcFfENru_ds9pVtZKGs,546
+opencode/_server.py,sha256=cd7P0OnUA6YbqlDmDjj2MDRvrsKOamdvPlWcvmlmFjw,2630
+opencode/_session.py,sha256=U7dhYkXrBtnkMmPuPSK1b2KYuyPQPzpie5kblIuoGKs,5840
+opencode/_tools.py,sha256=Tov-dr4x-03QAzwf1QHQzdxLEv10zv4LZkLWP79dXic,6020
+opencode_py-0.1.0.dist-info/METADATA,sha256=OMLzjfxNzMgKwlFhGsZhDVrEm3YceCK_Bj1WgLmrgtc,4570
+opencode_py-0.1.0.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
+opencode_py-0.1.0.dist-info/RECORD,,

opencode_py-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.30.1
+Root-Is-Purelib: true
+Tag: py3-none-any