oadson 1.0.0__py3-none-any.whl

oadson/config.py

@@ -0,0 +1,73 @@
+"""
+OADSON config — reads/writes ~/.oadson/config.json
+"""
+import json
+import os
+from pathlib import Path
+
+CONFIG_DIR = Path.home() / ".oadson"
+CONFIG_FILE = CONFIG_DIR / "config.json"
+
+
+def get_config() -> dict:
+    if CONFIG_FILE.exists():
+        try:
+            return json.loads(CONFIG_FILE.read_text())
+        except Exception:
+            return {}
+    return {}
+
+
+def save_config(cfg: dict):
+    CONFIG_DIR.mkdir(parents=True, exist_ok=True)
+    CONFIG_FILE.write_text(json.dumps(cfg, indent=2))
+
+
+def get_backend_url() -> str:
+    return get_config().get("backend_url", "").rstrip("/")
+
+
+def get_token() -> str:
+    return get_config().get("token", "")
+
+
+def get_permissions() -> dict:
+    """
+    Permission system for local tool execution.
+
+    auto_allow   — run without prompting
+    confirm      — show diff/plan, wait for y/n
+    always_backup — copy to .oadson_backup/ before touching
+    never_allow  — block outright (no override)
+    """
+    defaults = {
+        "auto_allow": [
+            "read_file", "list_dir", "git_status",
+            "git_diff", "search_files", "run_read_only",
+            "pwd", "ls", "cat", "find", "grep",
+            "head", "tail", "wc", "echo", "which",
+        ],
+        "confirm": [
+            "write_file", "create_file", "run_bash",
+            "git_commit", "git_push", "pip_install",
+            "npm_install",
+        ],
+        "always_backup": [
+            "delete_file", "overwrite_file",
+        ],
+        "never_allow": [
+            "rm -rf /", "rm -rf ~", ":(){ :|: & };:",
+            "dd if=", "mkfs", "format",
+        ],
+    }
+    cfg_perms = get_config().get("permissions", {})
+    # Merge user overrides with defaults
+    for key in defaults:
+        if key in cfg_perms:
+            defaults[key] = cfg_perms[key]
+    return defaults
+
+
+def is_configured() -> bool:
+    cfg = get_config()
+    return bool(cfg.get("backend_url") and cfg.get("token"))

oadson/context.py

@@ -0,0 +1,144 @@
+"""
+context.py — Auto shell context collector.
+
+Runs silently on every request. OADSON sees your shell state
+without you having to describe it. Mirrors how Claude Code works —
+it already knows your cwd, git branch, last error before you type.
+"""
+import os
+import subprocess
+from pathlib import Path
+
+
+def _run(cmd: str, timeout: int = 5) -> str:
+    try:
+        r = subprocess.run(
+            cmd, shell=True, capture_output=True,
+            text=True, timeout=timeout
+        )
+        return r.stdout.strip()
+    except Exception:
+        return ""
+
+
+def _run_err(cmd: str, timeout: int = 5) -> str:
+    try:
+        r = subprocess.run(
+            cmd, shell=True, capture_output=True,
+            text=True, timeout=timeout
+        )
+        return (r.stdout + r.stderr).strip()
+    except Exception:
+        return ""
+
+
+def collect(last_exit_code: int = 0, last_command: str = "") -> dict:
+    """
+    Collect shell context. Called before every backend request.
+    Fast — all subprocesses have a 5s timeout and failures are silent.
+    """
+    cwd = os.getcwd()
+    home = str(Path.home())
+
+    # Git context
+    git_branch = _run("git rev-parse --abbrev-ref HEAD 2>/dev/null")
+    git_status = _run("git status --short 2>/dev/null")
+    git_diff_stat = _run("git diff --stat HEAD 2>/dev/null | tail -1")
+
+    # Project type detection
+    project_type = _detect_project_type(cwd)
+
+    # Recent files changed (git-aware)
+    recent_files = _run("git diff --name-only HEAD 2>/dev/null | head -10")
+    if not recent_files:
+        # Fallback: recently modified files
+        recent_files = _run(
+            "find . -maxdepth 2 -newer . -type f "
+            "! -path './.git/*' ! -path './node_modules/*' "
+            "! -path './__pycache__/*' 2>/dev/null | head -10"
+        )
+
+    # Directory tree (shallow)
+    tree = _run(
+        "find . -maxdepth 2 -not -path './.git/*' "
+        "-not -path './node_modules/*' "
+        "-not -path './__pycache__/*' "
+        "-not -name '*.pyc' 2>/dev/null | head -40"
+    )
+
+    ctx = {
+        "cwd": cwd.replace(home, "~"),
+        "shell": os.environ.get("SHELL", "bash"),
+        "os": _run("uname -s") or "Linux",
+        "project_type": project_type,
+        "last_exit_code": last_exit_code,
+    }
+
+    if last_command:
+        ctx["last_command"] = last_command
+
+    if git_branch:
+        ctx["git"] = {
+            "branch": git_branch,
+            "status": git_status or "clean",
+            "diff_stat": git_diff_stat or "",
+            "changed_files": recent_files or "",
+        }
+
+    if tree:
+        ctx["directory_tree"] = tree
+
+    return ctx
+
+
+def _detect_project_type(cwd: str) -> str:
+    p = Path(cwd)
+    checks = [
+        (p / "package.json",        "node"),
+        (p / "pyproject.toml",      "python"),
+        (p / "requirements.txt",    "python"),
+        (p / "setup.py",            "python"),
+        (p / "Cargo.toml",          "rust"),
+        (p / "go.mod",              "go"),
+        (p / "pom.xml",             "java"),
+        (p / "Dockerfile",          "docker"),
+        (p / "docker-compose.yml",  "docker"),
+        (p / "main.py",             "python"),
+        (p / "index.js",            "node"),
+        (p / "index.ts",            "typescript"),
+    ]
+    for path, kind in checks:
+        if path.exists():
+            return kind
+    return "unknown"
+
+
+def format_for_prompt(ctx: dict) -> str:
+    """
+    Format context into a compact system prompt block.
+    Injected into every request so OADSON knows your shell state.
+    """
+    lines = [
+        "=== SHELL CONTEXT ===",
+        f"cwd: {ctx['cwd']}",
+        f"project: {ctx.get('project_type', 'unknown')}",
+        f"shell: {ctx.get('shell', 'bash')}",
+        f"os: {ctx.get('os', 'Linux')}",
+        f"last_exit_code: {ctx.get('last_exit_code', 0)}",
+    ]
+
+    if ctx.get("last_command"):
+        lines.append(f"last_command: {ctx['last_command']}")
+
+    if ctx.get("git"):
+        g = ctx["git"]
+        lines.append(f"git_branch: {g['branch']}")
+        lines.append(f"git_status: {g['status']}")
+        if g.get("changed_files"):
+            lines.append(f"changed_files:\n{g['changed_files']}")
+
+    if ctx.get("directory_tree"):
+        lines.append(f"directory_tree:\n{ctx['directory_tree']}")
+
+    lines.append("=== END CONTEXT ===")
+    return "\n".join(lines)

oadson/executor.py

@@ -0,0 +1,367 @@
+"""
+executor.py — Local tool executor.
+
+This is the Claude Code equivalent for OADSON.
+Tools are executed locally on YOUR machine, not on Railway.
+Railway sends the plan; this file carries it out — with your permission.
+
+Permission tiers:
+  auto_allow    → runs silently, no prompt
+  confirm       → shows what will change, waits for y/n
+  always_backup → copies file first, then confirms
+  never_allow   → blocked, no override
+"""
+import os
+import re
+import shutil
+import subprocess
+from datetime import datetime
+from pathlib import Path
+from typing import Optional
+
+from rich.console import Console
+from rich.syntax import Syntax
+from rich.panel import Panel
+from rich.prompt import Confirm
+
+from oadson.config import get_permissions
+
+console = Console()
+
+BACKUP_DIR = Path.home() / ".oadson" / "backups"
+
+
+# ── TOOL REGISTRY ──
+# Maps tool names the AI can call → local handler functions.
+
+def _backup_file(path: str) -> Optional[str]:
+    """Copy file to ~/.oadson/backups/ before touching it."""
+    src = Path(path)
+    if not src.exists():
+        return None
+    BACKUP_DIR.mkdir(parents=True, exist_ok=True)
+    ts = datetime.now().strftime("%Y%m%d_%H%M%S")
+    dest = BACKUP_DIR / f"{src.name}.{ts}.bak"
+    shutil.copy2(src, dest)
+    return str(dest)
+
+
+def _show_diff(path: str, new_content: str):
+    """Show a unified diff of current file vs proposed content."""
+    src = Path(path)
+    if src.exists():
+        old_lines = src.read_text().splitlines(keepends=True)
+    else:
+        old_lines = []
+    new_lines = new_content.splitlines(keepends=True)
+
+    import difflib
+    diff = list(difflib.unified_diff(
+        old_lines, new_lines,
+        fromfile=f"current: {path}",
+        tofile=f"proposed: {path}",
+        lineterm=""
+    ))
+    if diff:
+        diff_text = "\n".join(diff)
+        console.print(Syntax(diff_text, "diff", theme="monokai"))
+    else:
+        console.print("[dim]No changes.[/dim]")
+
+
+def _is_never_allowed(command: str, perms: dict) -> bool:
+    return any(blocked in command for blocked in perms.get("never_allow", []))
+
+
+def _get_tier(tool_name: str, command: str, perms: dict) -> str:
+    """Determine permission tier for this tool call."""
+    # Check never_allow first
+    if command and _is_never_allowed(command, perms):
+        return "never"
+
+    for item in perms.get("never_allow", []):
+        if item in tool_name:
+            return "never"
+
+    for item in perms.get("always_backup", []):
+        if item in tool_name:
+            return "backup"
+
+    for item in perms.get("confirm", []):
+        if item in tool_name:
+            return "confirm"
+
+    for item in perms.get("auto_allow", []):
+        if item in tool_name:
+            return "auto"
+
+    # Default: confirm anything unknown
+    return "confirm"
+
+
+# ── INDIVIDUAL TOOL HANDLERS ──
+
+def tool_read_file(args: dict) -> dict:
+    path = args.get("path", "")
+    try:
+        content = Path(path).read_text()
+        return {"status": "success", "content": content, "path": path}
+    except FileNotFoundError:
+        return {"status": "error", "reason": f"File not found: {path}"}
+    except Exception as e:
+        return {"status": "error", "reason": str(e)}
+
+
+def tool_write_file(args: dict) -> dict:
+    path = args.get("path", "")
+    content = args.get("content", "")
+    perms = get_permissions()
+    tier = _get_tier("write_file", "", perms)
+
+    if tier == "never":
+        return {"status": "blocked", "reason": "write_file is in never_allow"}
+
+    # Show diff
+    console.print(f"\n[bold yellow]⚡ OADSON wants to write:[/bold yellow] {path}")
+    _show_diff(path, content)
+
+    if tier == "backup":
+        backup = _backup_file(path)
+        if backup:
+            console.print(f"[dim]Backup saved to: {backup}[/dim]")
+
+    if tier in ("confirm", "backup"):
+        if not Confirm.ask("[bold]Apply this change?[/bold]"):
+            return {"status": "cancelled", "reason": "User declined"}
+
+    try:
+        p = Path(path)
+        p.parent.mkdir(parents=True, exist_ok=True)
+        p.write_text(content)
+        return {"status": "success", "path": path, "bytes": len(content)}
+    except Exception as e:
+        return {"status": "error", "reason": str(e)}
+
+
+def tool_create_file(args: dict) -> dict:
+    """Same as write_file but makes intent explicit."""
+    path = args.get("path", "")
+    content = args.get("content", "")
+    perms = get_permissions()
+
+    if Path(path).exists():
+        console.print(f"[bold yellow]⚠ File exists:[/bold yellow] {path} — treating as overwrite")
+        return tool_write_file(args)
+
+    console.print(f"\n[bold green]✨ OADSON wants to create:[/bold green] {path}")
+    if content:
+        lang = _detect_lang(path)
+        console.print(Panel(
+            Syntax(content, lang, theme="monokai", line_numbers=True),
+            title=f"New file: {path}",
+            border_style="green"
+        ))
+
+    tier = _get_tier("create_file", "", perms)
+    if tier in ("confirm", "backup"):
+        if not Confirm.ask("[bold]Create this file?[/bold]"):
+            return {"status": "cancelled", "reason": "User declined"}
+
+    try:
+        p = Path(path)
+        p.parent.mkdir(parents=True, exist_ok=True)
+        p.write_text(content)
+        return {"status": "success", "path": path, "created": True}
+    except Exception as e:
+        return {"status": "error", "reason": str(e)}
+
+
+def tool_delete_file(args: dict) -> dict:
+    path = args.get("path", "")
+    perms = get_permissions()
+
+    if not Path(path).exists():
+        return {"status": "error", "reason": f"File not found: {path}"}
+
+    # Always backup before delete
+    backup = _backup_file(path)
+    console.print(f"\n[bold red]🗑  OADSON wants to DELETE:[/bold red] {path}")
+    if backup:
+        console.print(f"[dim]Backup saved to: {backup}[/dim]")
+
+    if not Confirm.ask("[bold red]Confirm DELETE?[/bold red]"):
+        return {"status": "cancelled", "reason": "User declined"}
+
+    try:
+        Path(path).unlink()
+        return {"status": "success", "path": path, "deleted": True, "backup": backup}
+    except Exception as e:
+        return {"status": "error", "reason": str(e)}
+
+
+def tool_list_dir(args: dict) -> dict:
+    path = args.get("path", ".")
+    try:
+        p = Path(path)
+        items = []
+        for item in sorted(p.iterdir()):
+            items.append({
+                "name": item.name,
+                "type": "dir" if item.is_dir() else "file",
+                "size": item.stat().st_size if item.is_file() else None,
+            })
+        return {"status": "success", "path": str(p.resolve()), "items": items}
+    except Exception as e:
+        return {"status": "error", "reason": str(e)}
+
+
+def tool_run_bash(args: dict) -> dict:
+    """
+    Run a bash command locally.
+    Always confirms unless the command is in auto_allow patterns.
+    Shows exactly what will run before running it.
+    """
+    command = args.get("command", "").strip()
+    if not command:
+        return {"status": "error", "reason": "No command provided"}
+
+    perms = get_permissions()
+    tier = _get_tier("run_bash", command, perms)
+
+    if tier == "never":
+        return {"status": "blocked", "reason": f"Command blocked by never_allow: {command}"}
+
+    # Check auto_allow patterns
+    if tier == "auto":
+        # Double-check: if it has destructive patterns, force confirm anyway
+        destructive = ["rm ", "rmdir", "mv ", "chmod 777", "> /", "dd if"]
+        if any(d in command for d in destructive):
+            tier = "confirm"
+
+    if tier in ("confirm", "backup"):
+        console.print(f"\n[bold yellow]⚡ OADSON wants to run:[/bold yellow]")
+        console.print(Panel(
+            Syntax(command, "bash", theme="monokai"),
+            border_style="yellow"
+        ))
+        if not Confirm.ask("[bold]Run this command?[/bold]"):
+            return {"status": "cancelled", "reason": "User declined"}
+
+    try:
+        result = subprocess.run(
+            command,
+            shell=True,
+            capture_output=True,
+            text=True,
+            timeout=60,
+            cwd=os.getcwd(),
+        )
+        return {
+            "status": "success" if result.returncode == 0 else "error",
+            "command": command,
+            "stdout": result.stdout,
+            "stderr": result.stderr or None,
+            "return_code": result.returncode,
+        }
+    except subprocess.TimeoutExpired:
+        return {"status": "timeout", "command": command, "reason": "Command exceeded 60s"}
+    except Exception as e:
+        return {"status": "error", "command": command, "reason": str(e)}
+
+
+def tool_search_files(args: dict) -> dict:
+    pattern = args.get("pattern", "")
+    path = args.get("path", ".")
+    try:
+        result = subprocess.run(
+            f"grep -rn {repr(pattern)} {path} --include='*.py' --include='*.js' "
+            f"--include='*.ts' --include='*.json' --include='*.md' "
+            f"--exclude-dir=node_modules --exclude-dir=.git 2>/dev/null | head -50",
+            shell=True, capture_output=True, text=True, timeout=10
+        )
+        return {"status": "success", "matches": result.stdout}
+    except Exception as e:
+        return {"status": "error", "reason": str(e)}
+
+
+def tool_git_status(args: dict) -> dict:
+    try:
+        status = subprocess.run("git status", shell=True, capture_output=True, text=True).stdout
+        branch = subprocess.run("git branch --show-current", shell=True, capture_output=True, text=True).stdout.strip()
+        return {"status": "success", "branch": branch, "output": status}
+    except Exception as e:
+        return {"status": "error", "reason": str(e)}
+
+
+def tool_git_diff(args: dict) -> dict:
+    path = args.get("path", "")
+    cmd = f"git diff {path}" if path else "git diff"
+    try:
+        result = subprocess.run(cmd, shell=True, capture_output=True, text=True)
+        return {"status": "success", "diff": result.stdout}
+    except Exception as e:
+        return {"status": "error", "reason": str(e)}
+
+
+def tool_http_request(args: dict) -> dict:
+    """Fire HTTP requests — useful for testing your Railway API."""
+    import httpx
+    method = args.get("method", "GET").upper()
+    url = args.get("url", "")
+    headers = args.get("headers", {})
+    body = args.get("body", None)
+
+    console.print(f"\n[bold cyan]🌐 OADSON wants to call:[/bold cyan] {method} {url}")
+    if not Confirm.ask("[bold]Send request?[/bold]"):
+        return {"status": "cancelled"}
+
+    try:
+        with httpx.Client(timeout=30) as client:
+            resp = client.request(method, url, headers=headers, json=body)
+        return {
+            "status": "success",
+            "http_status": resp.status_code,
+            "headers": dict(resp.headers),
+            "body": resp.text[:4000],
+        }
+    except Exception as e:
+        return {"status": "error", "reason": str(e)}
+
+
+# ── TOOL DISPATCH TABLE ──
+TOOLS = {
+    "read_file":      tool_read_file,
+    "write_file":     tool_write_file,
+    "create_file":    tool_create_file,
+    "delete_file":    tool_delete_file,
+    "list_dir":       tool_list_dir,
+    "run_bash":       tool_run_bash,
+    "search_files":   tool_search_files,
+    "git_status":     tool_git_status,
+    "git_diff":       tool_git_diff,
+    "http_request":   tool_http_request,
+}
+
+
+def execute_tool(tool_name: str, args: dict) -> dict:
+    """
+    Dispatch a tool call from the AI to the local handler.
+    Returns result dict always — never raises.
+    """
+    handler = TOOLS.get(tool_name)
+    if not handler:
+        return {"status": "error", "reason": f"Unknown tool: {tool_name}"}
+    try:
+        return handler(args)
+    except Exception as e:
+        return {"status": "error", "reason": f"Tool {tool_name} crashed: {e}"}
+
+
+def _detect_lang(path: str) -> str:
+    ext = Path(path).suffix.lstrip(".")
+    return {
+        "py": "python", "js": "javascript", "ts": "typescript",
+        "json": "json", "md": "markdown", "sh": "bash",
+        "html": "html", "css": "css", "rs": "rust",
+        "go": "go", "yaml": "yaml", "yml": "yaml",
+    }.get(ext, "text")

oadson-1.0.0.dist-info/METADATA

@@ -0,0 +1,118 @@
+Metadata-Version: 2.4
+Name: oadson
+Version: 1.0.0
+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
+```