oadson 1.0.1__tar.gz

oadson-1.0.1/PKG-INFO

@@ -0,0 +1,118 @@
+Metadata-Version: 2.4
+Name: oadson
+Version: 1.0.1
+Summary: OADSON Terminal — AI coding agent for your local shell
+Author-email: Goodness Olayinka <goodnessolayinka2@gmail.com>
+License: MIT
+Project-URL: Homepage, https://github.com/goodnessolayinka/Oadson_v2
+Project-URL: Repository, https://github.com/goodnessolayinka/Oadson_v2
+Keywords: ai,cli,coding-agent,terminal,oadson
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+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: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Terminals
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: httpx>=0.27
+Requires-Dist: rich>=13
+Requires-Dist: typer>=0.12
+Requires-Dist: prompt_toolkit>=3.0
+
+# oadson
+
+**OADSON Terminal** — AI coding agent for your local shell.
+
+Powered by your Railway OADSON V2 backend.
+
+---
+
+## Install
+
+```bash
+pip install oadson
+```
+
+## Setup
+
+```bash
+oadson setup
+```
+
+Enter your Railway backend URL and API token when prompted.
+
+---
+
+## Usage
+
+### One-shot
+```bash
+oadson "fix the import error in main.py"
+oadson "write a README for this project"
+```
+
+### Interactive REPL
+```bash
+oadson
+```
+
+### Pipe mode
+```bash
+cat error.log | oadson
+cat file.py | oadson "refactor this"
+python main.py 2>&1 | oadson "what's wrong"
+```
+
+### Session management
+```bash
+oadson session new "auth refactor"
+oadson session list
+oadson session use 2
+oadson session delete 1
+```
+
+---
+
+## REPL commands
+
+| Command | Description |
+|---------|-------------|
+| `/new [name]` | Start fresh session |
+| `/sessions` | List all sessions |
+| `/delete N` | Delete session #N |
+| `/clear` | Clear screen |
+| `/help` | Show help |
+| `/exit` | Quit |
+
+---
+
+## Permission system
+
+OADSON always shows what it's about to do before doing it.
+
+| Action | Behaviour |
+|--------|-----------|
+| Read files, git status, ls | Auto — no prompt |
+| Write/create files | Shows diff → asks y/n |
+| Delete files | Auto-backup → asks y/n |
+| Run bash commands | Shows command → asks y/n |
+| Destructive patterns (`rm -rf /`) | Blocked always |
+
+Customize permissions in `~/.oadson/config.json`.
+
+---
+
+## Config location
+
+```
+~/.oadson/
+  config.json    ← backend URL, token, permissions
+  sessions.json  ← session history
+  history        ← REPL input history
+  backups/       ← auto-backups before delete/overwrite
+```

oadson-1.0.1/README.md

@@ -0,0 +1,92 @@
+# oadson
+
+**OADSON Terminal** — AI coding agent for your local shell.
+
+Powered by your Railway OADSON V2 backend.
+
+---
+
+## Install
+
+```bash
+pip install oadson
+```
+
+## Setup
+
+```bash
+oadson setup
+```
+
+Enter your Railway backend URL and API token when prompted.
+
+---
+
+## Usage
+
+### One-shot
+```bash
+oadson "fix the import error in main.py"
+oadson "write a README for this project"
+```
+
+### Interactive REPL
+```bash
+oadson
+```
+
+### Pipe mode
+```bash
+cat error.log | oadson
+cat file.py | oadson "refactor this"
+python main.py 2>&1 | oadson "what's wrong"
+```
+
+### Session management
+```bash
+oadson session new "auth refactor"
+oadson session list
+oadson session use 2
+oadson session delete 1
+```
+
+---
+
+## REPL commands
+
+| Command | Description |
+|---------|-------------|
+| `/new [name]` | Start fresh session |
+| `/sessions` | List all sessions |
+| `/delete N` | Delete session #N |
+| `/clear` | Clear screen |
+| `/help` | Show help |
+| `/exit` | Quit |
+
+---
+
+## Permission system
+
+OADSON always shows what it's about to do before doing it.
+
+| Action | Behaviour |
+|--------|-----------|
+| Read files, git status, ls | Auto — no prompt |
+| Write/create files | Shows diff → asks y/n |
+| Delete files | Auto-backup → asks y/n |
+| Run bash commands | Shows command → asks y/n |
+| Destructive patterns (`rm -rf /`) | Blocked always |
+
+Customize permissions in `~/.oadson/config.json`.
+
+---
+
+## Config location
+
+```
+~/.oadson/
+  config.json    ← backend URL, token, permissions
+  sessions.json  ← session history
+  history        ← REPL input history
+  backups/       ← auto-backups before delete/overwrite
+```

oadson-1.0.1/oadson/__init__.py

@@ -0,0 +1,2 @@
+"""OADSON Terminal — AI coding agent for your local shell."""
+__version__ = "1.0.1"

oadson-1.0.1/oadson/agent.py

@@ -0,0 +1,245 @@
+"""
+agent.py — Local agent loop.
+
+Sends your message + shell context to Railway.
+Railway's AI responds with text and/or tool calls.
+Tool calls are executed locally here, results fed back.
+Loop repeats until AI has no more tool calls.
+
+This is the core of OADSON terminal — same pattern as Claude Code.
+"""
+import json
+from typing import Optional
+
+import httpx
+from rich.console import Console
+from rich.live import Live
+from rich.spinner import Spinner
+from rich.text import Text
+
+from oadson.config import get_backend_url, get_token
+from oadson.context import collect, format_for_prompt
+from oadson.executor import execute_tool
+
+console = Console()
+
+MAX_ITERATIONS = 10   # safety cap on tool call loops
+REQUEST_TIMEOUT = 90  # seconds — generous for Nigeria network
+
+
+class NetworkError(Exception):
+    pass
+
+
+def _headers() -> dict:
+    return {
+        "Authorization": f"Bearer {get_token()}",
+        "Content-Type": "application/json",
+        "X-OADSON-Surface": "terminal",
+    }
+
+
+def _build_payload(
+    message: str,
+    session_id: str,
+    context: dict,
+    tool_results: Optional[list] = None,
+) -> dict:
+    payload = {
+        "message": message,
+        "session_id": session_id,
+        "surface": "terminal",
+        "context": format_for_prompt(context),
+    }
+    if tool_results:
+        payload["tool_results"] = tool_results
+    return payload
+
+
+def run(
+    message: str,
+    session_id: str,
+    last_exit_code: int = 0,
+    last_command: str = "",
+    stream: bool = True,
+) -> str:
+    """
+    Main agent loop. Call this for every user message.
+
+    Returns the final text reply from the AI.
+    Exits cleanly on network error — no crash, just a message.
+    """
+    backend = get_backend_url()
+    if not backend:
+        return "[bold red]⚠ Not configured.[/bold red] Run: oadson setup"
+
+    # Collect shell context
+    ctx = collect(last_exit_code=last_exit_code, last_command=last_command)
+
+    tool_results = []
+    final_reply = ""
+    iterations = 0
+
+    while iterations < MAX_ITERATIONS:
+        iterations += 1
+        payload = _build_payload(message, session_id, ctx, tool_results or None)
+
+        try:
+            if stream:
+                final_reply = _stream_request(backend, payload)
+            else:
+                final_reply = _plain_request(backend, payload)
+
+        except NetworkError as e:
+            return f"[bold red]⚠ No network:[/bold red] {e}\nYour session is safe — retry when connected."
+        except Exception as e:
+            return f"[bold red]⚠ Error:[/bold red] {e}"
+
+        # Parse tool calls from response
+        calls = _extract_tool_calls(final_reply)
+        if not calls:
+            break  # AI is done — no more tools needed
+
+        # Execute each tool locally
+        tool_results = []
+        for call in calls:
+            tool_name = call.get("tool")
+            args = call.get("args", {})
+
+            console.print(f"\n[dim]→ Tool: {tool_name}[/dim]")
+            result = execute_tool(tool_name, args)
+
+            tool_results.append({
+                "tool": tool_name,
+                "args": args,
+                "result": result,
+            })
+
+            # Show result summary
+            if result.get("status") == "success":
+                console.print(f"[green]✓ {tool_name}[/green]")
+            elif result.get("status") == "cancelled":
+                console.print(f"[yellow]↩ {tool_name} cancelled[/yellow]")
+            else:
+                console.print(f"[red]✗ {tool_name}: {result.get('reason', 'failed')}[/red]")
+
+        # Feed results back for next iteration
+        message = ""  # subsequent turns are tool-result driven
+
+    return final_reply
+
+
+def _stream_request(backend: str, payload: dict) -> str:
+    """
+    Calls /api/v2/chat/stream and parses the SSE response.
+    Backend sends a single "done" event with the full reply:
+      event: done
+      data: {"reply": "...", "model": "...", "steps": [...]}
+    """
+    url = f"{backend}/api/v2/chat/stream"
+    full_text = ""
+
+    try:
+        with httpx.Client(timeout=REQUEST_TIMEOUT) as client:
+            with client.stream("POST", url, json=payload, headers=_headers()) as resp:
+                if resp.status_code == 401:
+                    raise NetworkError("Invalid token — run: oadson setup")
+                if resp.status_code == 404:
+                    return _plain_request(backend, payload)
+                if resp.status_code != 200:
+                    raise NetworkError(f"HTTP {resp.status_code}")
+
+                for chunk in resp.iter_text():
+                    for line in chunk.splitlines():
+                        line = line.strip()
+                        if not line or line.startswith("event:"):
+                            continue
+                        if line.startswith("data:"):
+                            data_str = line[5:].strip()
+                            if data_str == "[DONE]":
+                                break
+                            try:
+                                data = json.loads(data_str)
+                                text = (
+                                    data.get("reply") or
+                                    data.get("text") or
+                                    data.get("token") or
+                                    data.get("content") or
+                                    data.get("response") or ""
+                                )
+                                if text:
+                                    full_text += text
+                                    console.print(text, end="", highlight=False)
+                            except json.JSONDecodeError:
+                                pass
+
+    except httpx.ConnectError as e:
+        raise NetworkError(f"Cannot reach {backend} — {e}")
+    except httpx.TimeoutException:
+        raise NetworkError(f"Request timed out after {REQUEST_TIMEOUT}s")
+
+    return full_text
+
+
+def _plain_request(backend: str, payload: dict) -> str:
+    """
+    Non-streaming fallback — shows spinner, returns full reply.
+    """
+    url = f"{backend}/api/v2/chat"
+
+    with Live(Spinner("dots", text="OADSON is thinking..."), console=console, refresh_per_second=10):
+        try:
+            with httpx.Client(timeout=REQUEST_TIMEOUT) as client:
+                resp = client.post(url, json=payload, headers=_headers())
+        except httpx.ConnectError as e:
+            raise NetworkError(f"Cannot reach {backend} — {e}")
+        except httpx.TimeoutException:
+            raise NetworkError(f"Request timed out after {REQUEST_TIMEOUT}s")
+
+    if resp.status_code == 401:
+        raise NetworkError("Invalid token — run: oadson setup")
+    if resp.status_code != 200:
+        raise NetworkError(f"HTTP {resp.status_code}: {resp.text[:200]}")
+
+    data = resp.json()
+    return (
+        data.get("response") or
+        data.get("text") or
+        data.get("message") or
+        str(data)
+    )
+
+
+def _extract_tool_calls(text: str) -> list:
+    """
+    Parse tool calls from AI response.
+    Railway returns them as JSON blocks: ```tool_call\n{...}\n```
+    or as a JSON array in the response body.
+    """
+    calls = []
+
+    # Format 1: ```tool_call\n{"tool": ..., "args": ...}\n```
+    import re
+    blocks = re.findall(r"```tool_call\s*\n([\s\S]*?)\n```", text)
+    for block in blocks:
+        try:
+            call = json.loads(block.strip())
+            if isinstance(call, list):
+                calls.extend(call)
+            elif isinstance(call, dict) and "tool" in call:
+                calls.append(call)
+        except json.JSONDecodeError:
+            pass
+
+    # Format 2: JSON array anywhere in text
+    if not calls:
+        arr = re.findall(r"\[\s*\{[^]]*\"tool\"[^]]*\}\s*\]", text, re.DOTALL)
+        for match in arr:
+            try:
+                parsed = json.loads(match)
+                if isinstance(parsed, list):
+                    calls.extend(parsed)
+            except json.JSONDecodeError:
+                pass
+
+    return calls