oadson 1.0.0__py3-none-any.whl

oadson/__init__.py

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

oadson/agent.py

@@ -0,0 +1,246 @@
+"""
+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:
+    """
+    Streaming request — prints words as they arrive.
+    Returns full text when done.
+    """
+    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:
+                    # Fallback to non-streaming
+                    return _plain_request(backend, payload)
+                if resp.status_code != 200:
+                    raise NetworkError(f"HTTP {resp.status_code}")
+
+                console.print()  # newline before streaming
+                for chunk in resp.iter_text():
+                    if chunk:
+                        # Handle SSE format: "data: {...}\n"
+                        for line in chunk.splitlines():
+                            if line.startswith("data: "):
+                                data_str = line[6:]
+                                if data_str.strip() == "[DONE]":
+                                    break
+                                try:
+                                    data = json.loads(data_str)
+                                    token = (
+                                        data.get("text") or
+                                        data.get("token") or
+                                        data.get("content") or
+                                        data.get("response") or ""
+                                    )
+                                    if token:
+                                        console.print(token, end="", highlight=False)
+                                        full_text += token
+                                except json.JSONDecodeError:
+                                    # Plain text chunk
+                                    console.print(line, end="", highlight=False)
+                                    full_text += line
+                console.print()  # newline after streaming
+
+    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

oadson/cli.py

@@ -0,0 +1,431 @@
+"""
+cli.py — OADSON Terminal CLI
+
+Modes:
+  oadson "fix the import error"     → one-shot
+  oadson                            → interactive REPL
+  oadson setup                      → configure backend + token
+  oadson config                     → show current config
+  oadson session new                → start fresh session
+  oadson session list               → list past sessions
+  cat error.log | oadson            → pipe mode
+"""
+import json
+import os
+import sys
+import uuid
+from pathlib import Path
+from typing import Optional
+
+import typer
+from rich.console import Console
+from rich.panel import Panel
+from rich.prompt import Prompt
+from rich.table import Table
+from prompt_toolkit import PromptSession
+from prompt_toolkit.history import FileHistory
+from prompt_toolkit.auto_suggest import AutoSuggestFromHistory
+from prompt_toolkit.styles import Style
+
+from oadson import agent
+from oadson.config import (
+    get_config, save_config, get_backend_url,
+    get_token, is_configured,
+)
+
+app = typer.Typer(
+    name="oadson",
+    help="OADSON Terminal — AI coding agent for your local shell",
+    add_completion=False,
+    no_args_is_help=False,
+)
+session_app = typer.Typer(help="Manage OADSON sessions")
+app.add_typer(session_app, name="session")
+
+console = Console()
+
+SESSIONS_FILE = Path.home() / ".oadson" / "sessions.json"
+HISTORY_FILE  = Path.home() / ".oadson" / "history"
+
+PROMPT_STYLE = Style.from_dict({
+    "prompt": "bold #00ff88",
+})
+
+
+# ── SESSION HELPERS ──
+
+def _load_sessions() -> dict:
+    if SESSIONS_FILE.exists():
+        try:
+            return json.loads(SESSIONS_FILE.read_text())
+        except Exception:
+            return {}
+    return {}
+
+
+def _save_sessions(sessions: dict):
+    SESSIONS_FILE.parent.mkdir(parents=True, exist_ok=True)
+    SESSIONS_FILE.write_text(json.dumps(sessions, indent=2))
+
+
+def _get_active_session() -> str:
+    sessions = _load_sessions()
+    active = sessions.get("active")
+    if active and active in sessions.get("history", {}):
+        return active
+    # Create default
+    return _create_session("default")
+
+
+def _create_session(name: str = "") -> str:
+    sessions = _load_sessions()
+    sid = f"terminal_{uuid.uuid4().hex[:8]}"
+    history = sessions.get("history", {})
+    history[sid] = {
+        "id": sid,
+        "name": name or sid,
+        "created": _now(),
+        "updated": _now(),
+    }
+    sessions["history"] = history
+    sessions["active"] = sid
+    _save_sessions(sessions)
+    return sid
+
+
+def _now() -> str:
+    from datetime import datetime
+    return datetime.now().strftime("%Y-%m-%d %H:%M")
+
+
+# ── COMMANDS ──
+
+@app.callback(invoke_without_command=True)
+def main(
+    ctx: typer.Context,
+    message: Optional[str] = typer.Argument(None, help="Message to send (one-shot mode)"),
+    no_stream: bool = typer.Option(False, "--no-stream", help="Disable streaming"),
+):
+    """
+    OADSON Terminal — AI coding agent.
+
+    One-shot:    oadson "explain this error"
+    Interactive: oadson
+    Pipe:        cat file.py | oadson
+    Setup:       oadson setup
+    """
+    if ctx.invoked_subcommand is not None:
+        return
+
+    if not is_configured():
+        console.print("[bold red]⚠ Not configured.[/bold red] Run: [bold]oadson setup[/bold]")
+        raise typer.Exit(1)
+
+    # Pipe mode: read from stdin
+    if not sys.stdin.isatty():
+        piped = sys.stdin.read().strip()
+        if message:
+            full = f"{piped}\n\n{message}"
+        else:
+            full = piped
+        _one_shot(full, stream=not no_stream)
+        return
+
+    # One-shot mode
+    if message:
+        _one_shot(message, stream=not no_stream)
+        return
+
+    # Interactive REPL
+    _repl(stream=not no_stream)
+
+
+def _one_shot(message: str, stream: bool = True):
+    sid = _get_active_session()
+    reply = agent.run(message, session_id=sid, stream=stream)
+    if not stream:
+        console.print(reply)
+
+
+def _repl(stream: bool = True):
+    """Interactive REPL with readline history and multiline support."""
+    console.print(Panel(
+        "[bold #00ff88]OADSON Terminal[/bold #00ff88]\n"
+        "[dim]AI coding agent — runs in your shell[/dim]\n\n"
+        "[dim]Commands: /new  /sessions  /exit  /help[/dim]",
+        border_style="#00ff88",
+    ))
+
+    sid = _get_active_session()
+    sessions = _load_sessions()
+    session_name = sessions.get("history", {}).get(sid, {}).get("name", sid)
+    console.print(f"[dim]Session: {session_name}[/dim]\n")
+
+    HISTORY_FILE.parent.mkdir(parents=True, exist_ok=True)
+    ps = PromptSession(
+        history=FileHistory(str(HISTORY_FILE)),
+        auto_suggest=AutoSuggestFromHistory(),
+        style=PROMPT_STYLE,
+        multiline=False,
+    )
+
+    last_exit = 0
+    last_cmd = ""
+
+    while True:
+        try:
+            user_input = ps.prompt("oadson> ").strip()
+        except (KeyboardInterrupt, EOFError):
+            console.print("\n[dim]Bye.[/dim]")
+            break
+
+        if not user_input:
+            continue
+
+        # ── REPL commands ──
+        if user_input.startswith("/"):
+            parts = user_input.split(None, 1)
+            cmd = parts[0].lower()
+            arg = parts[1] if len(parts) > 1 else ""
+
+            if cmd in ("/exit", "/quit", "/q"):
+                console.print("[dim]Bye.[/dim]")
+                break
+
+            elif cmd == "/new":
+                name = arg or ""
+                sid = _create_session(name)
+                console.print(f"[green]✓ New session started[/green]" + (f": {name}" if name else ""))
+
+            elif cmd in ("/sessions", "/history"):
+                _print_sessions()
+
+            elif cmd == "/delete":
+                _delete_session(arg)
+
+            elif cmd == "/help":
+                _print_help()
+
+            elif cmd == "/clear":
+                console.clear()
+
+            else:
+                console.print(f"[yellow]Unknown command: {cmd}[/yellow]")
+
+            continue
+
+        # ── Send to AI ──
+        reply = agent.run(
+            user_input,
+            session_id=sid,
+            last_exit_code=last_exit,
+            last_command=last_cmd,
+            stream=stream,
+        )
+
+        # Update session timestamp
+        _touch_session(sid)
+
+        last_cmd = user_input
+        last_exit = 0  # reset — we don't know actual exit code here
+
+        if not stream:
+            console.print(reply)
+        console.print()
+
+
+def _touch_session(sid: str):
+    sessions = _load_sessions()
+    if sid in sessions.get("history", {}):
+        sessions["history"][sid]["updated"] = _now()
+        _save_sessions(sessions)
+
+
+def _print_sessions():
+    sessions = _load_sessions()
+    history = sessions.get("history", {})
+    active = sessions.get("active", "")
+
+    if not history:
+        console.print("[dim]No sessions yet.[/dim]")
+        return
+
+    table = Table(title="OADSON Sessions", border_style="dim")
+    table.add_column("#", style="dim", width=3)
+    table.add_column("Name")
+    table.add_column("ID", style="dim")
+    table.add_column("Updated")
+    table.add_column("", width=2)
+
+    for i, (sid, info) in enumerate(
+        sorted(history.items(), key=lambda x: x[1].get("updated", ""), reverse=True), 1
+    ):
+        active_marker = "●" if sid == active else ""
+        table.add_row(
+            str(i),
+            info.get("name", sid),
+            sid,
+            info.get("updated", "—"),
+            f"[green]{active_marker}[/green]",
+        )
+
+    console.print(table)
+    console.print("[dim]/delete N  to delete session #N[/dim]")
+
+
+def _delete_session(arg: str):
+    sessions = _load_sessions()
+    history = sessions.get("history", {})
+    items = sorted(history.items(), key=lambda x: x[1].get("updated", ""), reverse=True)
+
+    try:
+        n = int(arg.strip())
+        sid, info = items[n - 1]
+    except (ValueError, IndexError):
+        console.print("[red]Usage: /delete N (e.g. /delete 1)[/red]")
+        return
+
+    from rich.prompt import Confirm
+    if not Confirm.ask(f"Delete session [bold]{info.get('name', sid)}[/bold]?"):
+        return
+
+    del history[sid]
+    if sessions.get("active") == sid:
+        # Switch to most recent remaining
+        if history:
+            sessions["active"] = sorted(
+                history.keys(),
+                key=lambda s: history[s].get("updated", ""), reverse=True
+            )[0]
+        else:
+            sessions.pop("active", None)
+
+    _save_sessions(sessions)
+    console.print(f"[green]✓ Deleted session: {info.get('name', sid)}[/green]")
+
+
+def _print_help():
+    console.print(Panel(
+        "[bold]REPL Commands:[/bold]\n"
+        "  /new [name]    Start a fresh session\n"
+        "  /sessions      List all sessions\n"
+        "  /delete N      Delete session #N\n"
+        "  /clear         Clear screen\n"
+        "  /help          Show this\n"
+        "  /exit          Quit\n\n"
+        "[bold]Pipe mode:[/bold]\n"
+        "  cat error.log | oadson\n"
+        "  cat file.py | oadson 'refactor this'\n\n"
+        "[bold]One-shot:[/bold]\n"
+        '  oadson "fix the broken import"\n'
+        '  oadson "write tests for main.py"',
+        title="OADSON Help",
+        border_style="dim",
+    ))
+
+
+# ── SETUP COMMAND ──
+
+@app.command()
+def setup():
+    """Configure OADSON with your Railway backend URL and token."""
+    console.print(Panel(
+        "[bold #00ff88]OADSON Setup[/bold #00ff88]",
+        border_style="#00ff88"
+    ))
+
+    cfg = get_config()
+
+    backend = Prompt.ask(
+        "Railway backend URL",
+        default=cfg.get("backend_url", "https://oadsonv2-production.up.railway.app")
+    ).strip().rstrip("/")
+
+    token = Prompt.ask(
+        "API token (from Railway env OADSON_SERVICE_TOKEN)",
+        password=True,
+        default=cfg.get("token", "")
+    ).strip()
+
+    cfg["backend_url"] = backend
+    cfg["token"] = token
+    save_config(cfg)
+
+    # Test connection
+    console.print("\n[dim]Testing connection...[/dim]")
+    try:
+        import httpx
+        r = httpx.get(
+            f"{backend}/health",
+            headers={"Authorization": f"Bearer {token}"},
+            timeout=10
+        )
+        if r.status_code in (200, 404):
+            console.print("[green]✓ Connected successfully[/green]")
+        else:
+            console.print(f"[yellow]⚠ HTTP {r.status_code} — check your URL and token[/yellow]")
+    except Exception as e:
+        console.print(f"[yellow]⚠ Could not connect: {e}[/yellow]")
+        console.print("[dim]Config saved anyway — retry when network is available[/dim]")
+
+    console.print(f"\n[bold]Config saved to:[/bold] ~/.oadson/config.json")
+    console.print("[bold green]✓ Ready. Run: oadson[/bold green]")
+
+
+@app.command("config")
+def show_config():
+    """Show current configuration."""
+    cfg = get_config()
+    if not cfg:
+        console.print("[yellow]Not configured. Run: oadson setup[/yellow]")
+        return
+
+    table = Table(border_style="dim")
+    table.add_column("Key")
+    table.add_column("Value")
+    table.add_row("backend_url", cfg.get("backend_url", "—"))
+    table.add_row("token", ("*" * 8 + cfg.get("token", "")[-4:]) if cfg.get("token") else "—")
+    console.print(table)
+
+
+# ── SESSION SUBCOMMANDS ──
+
+@session_app.command("new")
+def session_new(name: str = typer.Argument("", help="Optional session name")):
+    """Start a new session."""
+    sid = _create_session(name)
+    console.print(f"[green]✓ New session:[/green] {name or sid}")
+
+
+@session_app.command("list")
+def session_list():
+    """List all sessions."""
+    _print_sessions()
+
+
+@session_app.command("delete")
+def session_delete(n: int = typer.Argument(..., help="Session number from list")):
+    """Delete a session by number."""
+    _delete_session(str(n))
+
+
+@session_app.command("use")
+def session_use(n: int = typer.Argument(..., help="Session number to switch to")):
+    """Switch to a session by number."""
+    sessions = _load_sessions()
+    history = sessions.get("history", {})
+    items = sorted(history.items(), key=lambda x: x[1].get("updated", ""), reverse=True)
+
+    try:
+        sid, info = items[n - 1]
+    except IndexError:
+        console.print(f"[red]No session #{n}[/red]")
+        return
+
+    sessions["active"] = sid
+    _save_sessions(sessions)
+    console.print(f"[green]✓ Switched to:[/green] {info.get('name', sid)}")
+
+
+if __name__ == "__main__":
+    app()