refineo-cli 0.0.1__py3-none-any.whl

refineo_cli/__init__.py

@@ -0,0 +1,16 @@
+"""Refineo AI Text Humanizer CLI."""
+
+__version__ = "0.1.0"
+
+from .api import humanize, get_usage, start_device_code_flow, poll_for_token
+from .config import load_credentials, save_credentials, clear_credentials
+
+__all__ = [
+    "humanize",
+    "get_usage",
+    "start_device_code_flow",
+    "poll_for_token",
+    "load_credentials",
+    "save_credentials",
+    "clear_credentials",
+]

refineo_cli/api.py

@@ -0,0 +1,237 @@
+"""API client for Refineo."""
+
+import json
+import time
+import urllib.request
+import urllib.error
+from typing import Optional, Callable, TypedDict, Any
+
+from .config import (
+    API_BASE_URL,
+    Credentials,
+    load_credentials,
+    save_credentials,
+    is_token_expired,
+    get_platform_info,
+)
+
+
+class DeviceCodeResponse(TypedDict):
+    device_code: str
+    user_code: str
+    verification_uri: str
+    verification_uri_complete: str
+    expires_in: int
+    interval: int
+
+
+class HumanizeResult(TypedDict):
+    humanizedText: str
+    wordCount: int
+    model: str
+
+
+class UsageStats(TypedDict):
+    tier: str
+    used: int
+    limit: int
+    remaining: int
+    resetDate: Optional[str]
+    wordLimit: int
+    rateLimit: Optional[int]
+
+
+USER_AGENT = get_platform_info()
+
+
+def _make_request(
+    path: str,
+    method: str = "GET",
+    data: Optional[dict[str, Any]] = None,
+    headers: Optional[dict[str, str]] = None,
+) -> Any:
+    """Make an HTTP request."""
+    url = f"{API_BASE_URL}{path}"
+
+    req_headers = {
+        "Content-Type": "application/json",
+        "User-Agent": USER_AGENT,
+    }
+    if headers:
+        req_headers.update(headers)
+
+    body = None
+    if data is not None:
+        body = json.dumps(data).encode("utf-8")
+
+    req = urllib.request.Request(url, data=body, headers=req_headers, method=method)
+
+    try:
+        with urllib.request.urlopen(req, timeout=120) as response:
+            return json.loads(response.read().decode("utf-8"))
+    except urllib.error.HTTPError as e:
+        error_body = e.read().decode("utf-8")
+        try:
+            error_data = json.loads(error_body)
+            msg = (
+                error_data.get("message")
+                or error_data.get("error_description")
+                or error_data.get("error")
+                or f"HTTP {e.code}"
+            )
+            raise Exception(msg) from e
+        except json.JSONDecodeError:
+            raise Exception(f"HTTP {e.code}: {error_body}") from e
+
+
+def _api_request(
+    path: str,
+    method: str = "GET",
+    data: Optional[dict[str, Any]] = None,
+) -> Any:
+    """Make an authenticated API request."""
+    credentials = load_credentials()
+
+    if not credentials:
+        raise Exception("Not logged in. Run: refineo login")
+
+    # Refresh token if expired
+    token = credentials["accessToken"]
+    if is_token_expired(credentials):
+        refreshed = _refresh_token(credentials["refreshToken"])
+        if refreshed:
+            token = refreshed["accessToken"]
+        else:
+            raise Exception("Session expired. Run: refineo login")
+
+    return _make_request(
+        path,
+        method=method,
+        data=data,
+        headers={"Authorization": f"Bearer {token}"},
+    )
+
+
+def _refresh_token(refresh_token: str) -> Optional[Credentials]:
+    """Refresh access token."""
+    try:
+        data = _make_request(
+            "/api/auth/device/refresh",
+            method="POST",
+            data={
+                "refresh_token": refresh_token,
+                "grant_type": "refresh_token",
+            },
+        )
+
+        old_credentials = load_credentials()
+
+        credentials: Credentials = {
+            "accessToken": data["access_token"],
+            "refreshToken": data["refresh_token"],
+            "expiresAt": data["expires_at"],
+            "user": old_credentials["user"] if old_credentials else {"email": "", "tier": "", "name": None},
+        }
+
+        save_credentials(credentials)
+        return credentials
+    except Exception:
+        return None
+
+
+def start_device_code_flow() -> DeviceCodeResponse:
+    """Start device code flow."""
+    return _make_request("/api/auth/device/code", method="POST")
+
+
+def poll_for_token(
+    device_code: str,
+    interval: int,
+    expires_in: int,
+    on_poll: Optional[Callable[[], None]] = None,
+) -> Credentials:
+    """Poll for device code authorization."""
+    start_time = time.time()
+    timeout = expires_in
+
+    while time.time() - start_time < timeout:
+        if on_poll:
+            on_poll()
+
+        try:
+            data = _make_request(
+                "/api/auth/device/token",
+                method="POST",
+                data={
+                    "device_code": device_code,
+                    "grant_type": "urn:ietf:params:oauth:grant-type:device_code",
+                },
+            )
+
+            # Success!
+            credentials: Credentials = {
+                "accessToken": data["access_token"],
+                "refreshToken": data["refresh_token"],
+                "expiresAt": data["expires_at"],
+                "user": data.get("user", {"email": "", "tier": "", "name": None}),
+            }
+            save_credentials(credentials)
+            return credentials
+
+        except Exception as e:
+            error_msg = str(e)
+
+            if "authorization_pending" in error_msg:
+                time.sleep(interval)
+                continue
+
+            if "slow_down" in error_msg:
+                time.sleep(interval + 5)
+                continue
+
+            if "access_denied" in error_msg:
+                raise Exception(
+                    "Access denied. CLI requires Pro or Ultra subscription."
+                ) from e
+
+            if "expired_token" in error_msg:
+                raise Exception("Login timed out. Please try again.") from e
+
+            raise
+
+    raise Exception("Login timed out. Please try again.")
+
+
+def humanize(
+    text: str,
+    model: str = "enhanced",
+) -> HumanizeResult:
+    """Humanize text."""
+    api_model = "BALANCE" if model == "standard" else "ENHANCED"
+
+    result = _api_request(
+        "/api/humanize",
+        method="POST",
+        data={"text": text, "model": api_model},
+    )
+
+    return {
+        "humanizedText": result["data"]["humanizedText"],
+        "wordCount": result["data"]["wordCount"],
+        "model": result["data"]["model"],
+    }
+
+
+def get_usage() -> UsageStats:
+    """Get usage stats."""
+    result = _api_request("/api/usage")
+
+    return {
+        "tier": result["tier"],
+        "used": result["used"],
+        "limit": result["limit"],
+        "remaining": result["remaining"],
+        "resetDate": result.get("resetDate"),
+        "wordLimit": result["wordLimit"],
+        "rateLimit": result.get("rateLimit"),
+    }

refineo_cli/cli.py

@@ -0,0 +1,293 @@
+#!/usr/bin/env python3
+"""Refineo CLI entry point."""
+
+import subprocess
+import sys
+import platform
+from pathlib import Path
+
+from .config import load_credentials, clear_credentials
+from .api import start_device_code_flow, poll_for_token, humanize, get_usage
+
+VERSION = "0.1.0"
+
+# ANSI colors
+RESET = "\033[0m"
+BOLD = "\033[1m"
+DIM = "\033[2m"
+GREEN = "\033[32m"
+YELLOW = "\033[33m"
+BLUE = "\033[34m"
+CYAN = "\033[36m"
+RED = "\033[31m"
+
+
+def print_error(message: str) -> None:
+    """Print error message."""
+    print(f"{RED}Error:{RESET} {message}", file=sys.stderr)
+
+
+def print_success(message: str) -> None:
+    """Print success message."""
+    print(f"{GREEN}✓{RESET} {message}")
+
+
+def open_browser(url: str) -> None:
+    """Open URL in default browser."""
+    system = platform.system()
+
+    try:
+        if system == "Darwin":
+            subprocess.run(["open", url], check=True, capture_output=True)
+        elif system == "Windows":
+            subprocess.run(["start", "", url], check=True, capture_output=True, shell=True)
+        else:
+            subprocess.run(["xdg-open", url], check=True, capture_output=True)
+    except Exception:
+        print(f"Please open this URL in your browser: {url}")
+
+
+def login_command() -> None:
+    """Login command."""
+    existing = load_credentials()
+    if existing:
+        print(f"Already logged in as {CYAN}{existing['user']['email']}{RESET}")
+        print(f"Tier: {BOLD}{existing['user']['tier']}{RESET}")
+        print(f"\nRun {DIM}refineo logout{RESET} to switch accounts.")
+        return
+
+    print(f"{BOLD}Refineo CLI Login{RESET}\n")
+
+    try:
+        device_code = start_device_code_flow()
+
+        print(f"Your code: {BOLD}{CYAN}{device_code['user_code']}{RESET}\n")
+        print("Opening browser to authorize...")
+        print(f"{DIM}{device_code['verification_uri_complete']}{RESET}\n")
+
+        open_browser(device_code["verification_uri_complete"])
+
+        print("Waiting for authorization...", end="", flush=True)
+
+        dots = [0]
+
+        def on_poll() -> None:
+            dots[0] = (dots[0] % 3) + 1
+            print(f"\rWaiting for authorization{'.' * dots[0]}   ", end="", flush=True)
+
+        credentials = poll_for_token(
+            device_code["device_code"],
+            device_code["interval"],
+            device_code["expires_in"],
+            on_poll,
+        )
+
+        print("\r                                    \r", end="")
+        print_success(f"Logged in as {CYAN}{credentials['user']['email']}{RESET}")
+        print(f"Tier: {BOLD}{credentials['user']['tier']}{RESET}")
+
+    except Exception as e:
+        print()
+        print_error(str(e))
+        sys.exit(1)
+
+
+def logout_command() -> None:
+    """Logout command."""
+    credentials = load_credentials()
+
+    if not credentials:
+        print("Not logged in.")
+        return
+
+    clear_credentials()
+    print_success(f"Logged out from {credentials['user']['email']}")
+
+
+def stats_command() -> None:
+    """Stats command."""
+    credentials = load_credentials()
+
+    if not credentials:
+        print_error("Not logged in. Run: refineo login")
+        sys.exit(1)
+
+    try:
+        usage = get_usage()
+
+        print(f"{BOLD}Refineo Usage{RESET}\n")
+        print(f"Account: {CYAN}{credentials['user']['email']}{RESET}")
+        print(f"Plan: {BOLD}{usage['tier']}{RESET}")
+        print()
+
+        if usage["limit"] == -1:
+            print(f"Requests: {GREEN}Unlimited{RESET}")
+            if usage.get("rateLimit"):
+                print(f"Rate limit: {usage['rateLimit']} requests/hour")
+        else:
+            percentage = round((usage["used"] / usage["limit"]) * 100)
+            color = RED if percentage >= 90 else YELLOW if percentage >= 70 else GREEN
+            print(f"Requests: {color}{usage['used']}{RESET} / {usage['limit']} ({percentage}%)")
+            print(f"Remaining: {usage['remaining']}")
+
+        print(f"Word limit: {usage['wordLimit']} words/request")
+
+        if usage.get("resetDate"):
+            print(f"Resets: {usage['resetDate']}")
+
+    except Exception as e:
+        print_error(str(e))
+        sys.exit(1)
+
+
+def humanize_command(args: list[str]) -> None:
+    """Humanize command."""
+    credentials = load_credentials()
+
+    if not credentials:
+        print_error("Not logged in. Run: refineo login")
+        sys.exit(1)
+
+    # Parse arguments
+    text = ""
+    model = "enhanced"
+    input_file = ""
+    output_file = ""
+
+    i = 0
+    while i < len(args):
+        arg = args[i]
+
+        if arg in ("--model", "-m"):
+            i += 1
+            if i < len(args):
+                value = args[i]
+                if value in ("standard", "enhanced"):
+                    model = value
+                else:
+                    print_error('Model must be "standard" or "enhanced"')
+                    sys.exit(1)
+        elif arg in ("--file", "-f"):
+            i += 1
+            if i < len(args):
+                input_file = args[i]
+        elif arg in ("--output", "-o"):
+            i += 1
+            if i < len(args):
+                output_file = args[i]
+        elif not arg.startswith("-"):
+            text = arg
+
+        i += 1
+
+    # Read from file if specified
+    if input_file:
+        path = Path(input_file)
+        if not path.exists():
+            print_error(f"File not found: {input_file}")
+            sys.exit(1)
+        text = path.read_text()
+
+    # Read from stdin if no text provided
+    if not text:
+        if sys.stdin.isatty():
+            print_error(
+                'No text provided. Usage: refineo humanize "your text" or echo "text" | refineo humanize'
+            )
+            sys.exit(1)
+        text = sys.stdin.read().strip()
+
+    if not text:
+        print_error("No text provided")
+        sys.exit(1)
+
+    try:
+        result = humanize(text, model)
+
+        if output_file:
+            Path(output_file).write_text(result["humanizedText"])
+            print_success(f"Output written to {output_file}")
+        else:
+            print(result["humanizedText"])
+
+    except Exception as e:
+        print_error(str(e))
+        sys.exit(1)
+
+
+def help_command() -> None:
+    """Help command."""
+    print(f"""
+{BOLD}Refineo CLI{RESET} - AI Text Humanizer
+Version {VERSION}
+
+{BOLD}Usage:{RESET}
+  refineo <command> [options]
+
+{BOLD}Commands:{RESET}
+  login              Authenticate with your Refineo account
+  logout             Clear stored credentials
+  stats              Show usage statistics
+  humanize <text>    Humanize AI-generated text
+
+{BOLD}Humanize Options:{RESET}
+  -m, --model <model>   Model: "standard" or "enhanced" (default: enhanced)
+  -f, --file <path>     Read input from file
+  -o, --output <path>   Write output to file
+
+{BOLD}Examples:{RESET}
+  {DIM}# Login to your account{RESET}
+  refineo login
+
+  {DIM}# Humanize text directly{RESET}
+  refineo humanize "The results indicate a significant correlation."
+
+  {DIM}# Use standard model{RESET}
+  refineo humanize "Text here" --model standard
+
+  {DIM}# Read from file{RESET}
+  refineo humanize --file input.txt --output output.txt
+
+  {DIM}# Pipe from stdin{RESET}
+  echo "AI-generated text" | refineo humanize
+
+  {DIM}# Check usage{RESET}
+  refineo stats
+
+{BOLD}More Info:{RESET}
+  https://refineo.app/docs/cli
+""")
+
+
+def version_command() -> None:
+    """Version command."""
+    print(f"refineo {VERSION}")
+
+
+def main() -> None:
+    """Main entry point."""
+    args = sys.argv[1:]
+    command = args[0] if args else None
+
+    if command == "login":
+        login_command()
+    elif command == "logout":
+        logout_command()
+    elif command == "stats":
+        stats_command()
+    elif command == "humanize":
+        humanize_command(args[1:])
+    elif command in ("help", "--help", "-h"):
+        help_command()
+    elif command in ("version", "--version", "-v"):
+        version_command()
+    elif command is None:
+        help_command()
+    else:
+        print_error(f"Unknown command: {command}")
+        print(f"Run {DIM}refineo help{RESET} for usage.")
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

refineo_cli/config.py

@@ -0,0 +1,80 @@
+"""Configuration and credentials management."""
+
+import json
+import os
+import platform
+from pathlib import Path
+from typing import TypedDict, Optional
+
+
+class UserInfo(TypedDict):
+    email: str
+    name: Optional[str]
+    tier: str
+
+
+class Credentials(TypedDict):
+    accessToken: str
+    refreshToken: str
+    expiresAt: int
+    user: UserInfo
+
+
+CONFIG_DIR = Path.home() / ".refineo"
+CREDENTIALS_FILE = CONFIG_DIR / "credentials.json"
+
+API_BASE_URL = os.environ.get("REFINEO_API_URL", "https://refineo.app")
+
+
+def ensure_config_dir() -> None:
+    """Ensure config directory exists with proper permissions."""
+    CONFIG_DIR.mkdir(mode=0o700, parents=True, exist_ok=True)
+
+
+def load_credentials() -> Optional[Credentials]:
+    """Load credentials from disk."""
+    try:
+        if not CREDENTIALS_FILE.exists():
+            return None
+        data = json.loads(CREDENTIALS_FILE.read_text())
+        return data
+    except Exception:
+        return None
+
+
+def save_credentials(credentials: Credentials) -> None:
+    """Save credentials to disk."""
+    ensure_config_dir()
+    CREDENTIALS_FILE.write_text(json.dumps(credentials, indent=2))
+    CREDENTIALS_FILE.chmod(0o600)
+
+
+def clear_credentials() -> None:
+    """Clear credentials from disk."""
+    try:
+        if CREDENTIALS_FILE.exists():
+            CREDENTIALS_FILE.unlink()
+    except Exception:
+        pass
+
+
+def is_token_expired(credentials: Credentials) -> bool:
+    """Check if credentials are expired (with 1 minute buffer)."""
+    import time
+    now = int(time.time())
+    return credentials["expiresAt"] <= now + 60
+
+
+def get_platform_info() -> str:
+    """Get current platform info for User-Agent."""
+    system = platform.system()
+    arch = platform.machine()
+    py_version = platform.python_version()
+
+    os_name = {
+        "Darwin": "macOS",
+        "Windows": "Windows",
+        "Linux": "Linux",
+    }.get(system, "Unknown")
+
+    return f"refineo-cli/0.1.0 ({os_name}; {arch}) Python/{py_version}"

refineo_cli-0.0.1.dist-info/METADATA

@@ -0,0 +1,148 @@
+Metadata-Version: 2.4
+Name: refineo-cli
+Version: 0.0.1
+Summary: Refineo AI Text Humanizer CLI - Transform AI-generated text into natural human writing
+Project-URL: Homepage, https://refineo.ai
+Project-URL: Repository, https://github.com/refineo/refineo-ai-tools
+Project-URL: Issues, https://github.com/refineo/refineo-ai-tools/issues
+Author: Refineo
+License-Expression: MIT
+Keywords: ai,cli,humanizer,mcp,refineo,text,writing
+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
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Text Processing
+Requires-Python: >=3.10
+Provides-Extra: dev
+Requires-Dist: mypy>=1.13.0; extra == 'dev'
+Requires-Dist: pytest>=8.0.0; extra == 'dev'
+Requires-Dist: ruff>=0.8.0; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# Refineo AI Tools
+
+[![PyPI Downloads](https://img.shields.io/pypi/dm/refineo-cli)](https://pypi.org/project/refineo-cli/)
+[![npm Downloads](https://img.shields.io/npm/dm/@refineo/cli)](https://www.npmjs.com/package/@refineo/cli)
+
+CLI and MCP tools for [Refineo](https://refineo.app) - Transform AI-generated text into natural human writing.
+
+## Quick Start
+
+### Node.js / TypeScript
+
+```bash
+# Using bunx (recommended)
+bunx @refineo/cli login
+
+# Using npx
+npx @refineo/cli login
+
+# Global install
+npm i -g @refineo/cli && refineo login
+```
+
+### Python
+
+```bash
+# Using uvx (recommended)
+uvx refineo-cli login
+
+# Using pipx
+pipx run refineo-cli login
+
+# Global install
+pip install refineo-cli && refineo login
+```
+
+## Commands
+
+```bash
+refineo login              # Authenticate with your account
+refineo logout             # Clear stored credentials
+refineo stats              # Show usage statistics
+refineo humanize "text"    # Humanize AI-generated text
+```
+
+### Humanize Options
+
+```bash
+refineo humanize "text" --model enhanced    # Use enhanced model (default)
+refineo humanize "text" --model standard    # Use standard model
+refineo humanize --file input.txt           # Read from file
+refineo humanize --file input.txt --output output.txt  # Write to file
+echo "text" | refineo humanize              # Read from stdin
+```
+
+## Requirements
+
+- **Pro or Ultra subscription** - CLI/MCP access is a Pro+ feature
+- Node.js 18+ (for Node CLI)
+- Python 3.10+ (for Python CLI)
+
+## Authentication
+
+The CLI uses device code flow for secure authentication:
+
+1. Run `refineo login`
+2. A browser opens to authorize the device
+3. Enter the code shown in your terminal
+4. Credentials are stored securely in `~/.refineo/`
+
+## MCP Integration
+
+Refineo provides an MCP (Model Context Protocol) endpoint for integration with Claude, Cursor, and other AI tools.
+
+### Tools Available
+
+- **humanize** - Transform AI-generated text into natural human writing
+- **get_usage** - Check remaining quota for current billing period
+
+### Configuration
+
+Add to your Claude/Cursor MCP config:
+
+```json
+{
+  "mcpServers": {
+    "refineo": {
+      "url": "https://refineo.app/api/mcp",
+      "transport": "http",
+      "authentication": {
+        "type": "bearer",
+        "token": "<your-access-token>"
+      }
+    }
+  }
+}
+```
+
+Get your access token by running `refineo login` and checking `~/.refineo/credentials.json`.
+
+## Development
+
+### Node CLI
+
+```bash
+cd node
+npm install
+npm run build
+npm run test
+```
+
+### Python CLI
+
+```bash
+cd python
+pip install -e ".[dev]"
+pytest
+```
+
+## License
+
+MIT

refineo_cli-0.0.1.dist-info/RECORD

@@ -0,0 +1,8 @@
+refineo_cli/__init__.py,sha256=BIzN5T8plbx6FDib_3JXo9kMzlk-8FskiOx0OeznLEI,385
+refineo_cli/api.py,sha256=U_lrTu56pW-y33rvDsUb5npNEoyNpU_VQNKjlCB3o8E,6248
+refineo_cli/cli.py,sha256=LOKuMWP0n2C5gVtMwTkyjT36oKLYr35Ujqc2wApYBkQ,8033
+refineo_cli/config.py,sha256=EXiRtiaWbJ_NhFsGSDQD3igrtezpsmgwrd-Pi5V-n6A,1976
+refineo_cli-0.0.1.dist-info/METADATA,sha256=S7xQgz1Zm6VOdBE59gpwjKAmxNTn-9TSCpF8n7XXJlQ,3714
+refineo_cli-0.0.1.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+refineo_cli-0.0.1.dist-info/entry_points.txt,sha256=0ZfAhBoW3AWkwIZDD_ZXcHbB4KwsBI3-dWB_lHxO6_g,49
+refineo_cli-0.0.1.dist-info/RECORD,,

refineo_cli-0.0.1.dist-info/WHEEL

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

refineo_cli-0.0.1.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+refineo = refineo_cli.cli:main