oko-cli 0.1.0__tar.gz

oko_cli-0.1.0/.gitignore

@@ -0,0 +1,85 @@
+# Entornos virtuales
+.env
+.venv
+venv/
+env/
+ENV/
+env.bak/
+venv.bak/
+
+# Python cache y compilados
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+
+# Eggs y distribución
+*.egg
+*.egg-info/
+.eggs/
+eggs/
+develop-eggs/
+oko.egg-info
+
+# Build y distribución
+build/
+dist/
+sdist/
+wheels/
+*.egg-info
+*.egg
+
+# Instalación
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Testing y coverage
+.coverage
+htmlcov/
+.tox/
+.nox/
+.pytest_cache/
+nosetests.xml
+coverage.xml
+*.cover
+
+# Jupyter Notebook
+.ipynb_checkpoints/
+
+# IDE/Editores
+.vscode/
+.idea/
+*.swp
+*.swo
+*~
+.project
+.pydevproject
+
+# Sistema operativo
+.DS_Store
+.DS_Store?
+._*
+.Spotlight-V100
+.Trashes
+ehthumbs.db
+Thumbs.db
+
+# Configuraciones y secretos
+*.env
+.env.local
+.env.development.local
+.env.test.local
+.env.production.local
+secrets.py
+config_local.py
+config.ini
+settings_local.py
+credentials.json
+service_account.json
+
+# Logs
+*.log
+logs/
+
+# Archivos temporales

oko_cli-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Edward Ojeda
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

oko_cli-0.1.0/PKG-INFO

@@ -0,0 +1,29 @@
+Metadata-Version: 2.4
+Name: oko-cli
+Version: 0.1.0
+Summary: Elegant CLI for API endpoint testing
+Project-URL: Homepage, https://github.com/poll7872/oko
+Project-URL: Repository, https://github.com/tuusuario/oko
+Project-URL: Issues, https://github.com/poll7872/oko/issues
+Author-email: Edward Ojeda <edward.ojeda.es@gmail.com>
+License: MIT
+License-File: LICENSE
+Keywords: api,cli,endpoints,http,rest,testing
+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.8
+Classifier: Programming Language :: Python :: 3.9
+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 :: Testing
+Requires-Python: >=3.8
+Requires-Dist: httpx>=0.25.0
+Requires-Dist: rich>=13.0.0
+Requires-Dist: typer>=0.9.0
+Description-Content-Type: text/markdown
+
+Proyecto OKO

oko_cli-0.1.0/README.md

@@ -0,0 +1 @@
+Proyecto OKO

oko_cli-0.1.0/oko/cli.py

@@ -0,0 +1,207 @@
+from typing import List, Optional
+import typer
+from rich.prompt import Prompt, Confirm
+from rich.panel import Panel
+from datetime import datetime
+from pathlib import Path
+
+from .core.config import config, ConfigType, load_endpoints
+from .core.endpoints import add_endpoint
+from .core.runner import run_endpoint
+from .ui import (
+    console,
+    print_logo,
+    print_success,
+    print_error,
+    print_warning,
+    print_info_panel,
+    get_table,
+)
+
+app = typer.Typer(
+    help="OKO CLI - API Testing made simple",
+    rich_markup_mode="rich",
+    no_args_is_help=True,
+)
+endpoint_app = typer.Typer(help="Manage API endpoints")
+app.add_typer(endpoint_app, name="endpoint")
+
+
+@app.command("init")
+def init():
+    """Initialize OKO configuration."""
+    print_logo()
+    console.print("[bold primary]🚀 Welcome to OKO CLI![/bold primary]")
+    console.print("Let's set up your configuration.\n")
+
+    if config.find_config():
+        current_config = config.load_config()
+        warning_message = (
+            f"Configuration already exists at: [info]{config.config_dir}[/info]\n"
+            f"Type: [info]{current_config.get('type', 'unknown')}[/info]"
+        )
+        print_warning(warning_message, title="Configuration Found")
+
+        if not Confirm.ask("\nDo you want to reinitialize?"):
+            console.print("[dim]Initialization cancelled.[/dim]")
+            return
+
+    console.print("\n[bold primary]Where would you like to store endpoints?[/bold primary]")
+    options = [
+        ("project", "In this project (.oko/) - For team collaboration"),
+        ("global", "Global (~/.oko/) - For personal use"),
+        ("custom", "Custom location - Specify a path"),
+    ]
+
+    for i, (_, desc) in enumerate(options, 1):
+        console.print(f"  [secondary]{i}[/secondary]. {desc}")
+
+    choice = Prompt.ask("\nSelect option (1-3)", choices=["1", "2", "3"], default="1")
+
+    config_type: ConfigType
+    config_dir: Path
+
+    if choice == "1":
+        config_type = "project"
+        config_dir = Path.cwd() / ".oko"
+    elif choice == "2":
+        config_type = "global"
+        config_dir = Path.home() / ".oko"
+    else:
+        config_type = "custom"
+        custom_path = Prompt.ask("\nEnter custom path")
+        config_dir = Path(custom_path).expanduser().resolve()
+
+    project_name = None
+    if config_type == "project":
+        project_name = Prompt.ask("\nProject name", default=Path.cwd().name)
+
+    summary = (
+        f"  [bold]Type:[/bold] [info]{config_type}[/info]\n"
+        f"  [bold]Location:[/bold] [info]{config_dir}[/info]\n"
+    )
+    if project_name:
+        summary += f"  [bold]Project:[/bold] [info]{project_name}[/info]"
+
+    print_info_panel(summary, title="Summary")
+
+    if not Confirm.ask("\nCreate configuration?"):
+        console.print("[dim]Cancelled.[/dim]")
+        return
+
+    config_data = {
+        "created_at": datetime.now().isoformat(),
+        "project_name": project_name,
+    }
+    config.save_config(config_type, config_dir, config_data)
+
+    success_message = (
+        f"Configuration saved at: [info]{config.config_dir}[/info]\n\n"
+        "[bold]Next steps:[/bold]\n"
+        "  • Add an endpoint: [secondary]oko endpoint add <alias> <url>[/secondary]\n"
+        "  • Run an endpoint: [secondary]oko run <alias>[/secondary]"
+    )
+    print_success(success_message, title="✅ OKO initialized successfully!")
+
+
+@app.command("info")
+def info():
+    """Show current OKO configuration."""
+    if not config.find_config():
+        print_warning("No OKO configuration found. Run [secondary]oko init[/secondary] to get started.")
+        return
+
+    print_logo()
+    current_config = config.load_config()
+
+    config_details = (
+        f"  [bold]Type:[/bold] [info]{current_config.get('type', 'unknown')}[/info]\n"
+        f"  [bold]Location:[/bold] [info]{config.config_dir}[/info]\n"
+        f"  [bold]Version:[/bold] [info]{current_config.get('version', '1.0')}[/info]\n"
+    )
+    if current_config.get("project_name"):
+        config_details += f"  [bold]Project:[/bold] [info]{current_config.get('project_name')}[/info]\n"
+    if current_config.get("created_at"):
+        config_details += f"  [bold]Created:[/bold] [info]{current_config.get('created_at')}[/info]"
+
+    print_info_panel(config_details, title="OKO Configuration")
+
+    endpoints_data = load_endpoints()
+    endpoints = endpoints_data.get("endpoints", {})
+    console.print(f"\n[bold primary]📊 Endpoints found:[/bold primary] [bold secondary]{len(endpoints)}[/bold secondary]")
+
+    if endpoints:
+        table = get_table()
+        table.add_column("Alias", style="blue", no_wrap=True)
+        table.add_column("Method", style="cyan")
+        table.add_column("URL", style="white")
+
+        for alias, endpoint in endpoints.items():
+            method = endpoint.get("method", "GET")
+            url = endpoint.get("url", "")
+            table.add_row(alias, method, url[:70] + ("..." if len(url) > 70 else ""))
+        
+        console.print(table)
+
+
+@endpoint_app.command("add")
+def endpoint_add(
+    alias: str = typer.Argument(..., help="Alias to identify the endpoint"),
+    url: str = typer.Argument(..., help="Full URL of the endpoint"),
+    method: str = typer.Option(
+        "GET", "--method", "-M", help="HTTP method"
+    ),
+):
+    """Register a new endpoint."""
+    if not config.find_config():
+        print_warning("No OKO configuration found. Run [secondary]oko init[/secondary] first.")
+        raise typer.Exit(1)
+
+    method = method.upper()
+    SUPPORTED_METHODS = ["GET", "POST", "PUT", "DELETE", "PATCH", "HEAD", "OPTIONS"]
+
+    if method not in SUPPORTED_METHODS:
+        print_error(f"Method '{method}' not supported. Choose from: [info]{', '.join(SUPPORTED_METHODS)}[/info]")
+        raise typer.Exit(1)
+
+    add_endpoint(alias, url, method)
+    
+    message = (
+        f"Alias: [primary]{alias}[/primary]\n"
+        f"URL: [info]{method} {url}[/info]\n"
+        f"Saved in: [dim]{config.config_dir}[/dim]"
+    )
+    print_success(message, title=f"Endpoint '{alias}' saved!")
+
+
+@app.command("run")
+def run(
+    alias: str,
+    param: List[str] = typer.Option(
+        None, "--param", "-p", help="Query params (key=value). Use multiple times."
+    ),
+    header: List[str] = typer.Option(
+        None, "--header", "-H", help="HTTP headers (key=value). Use multiple times."
+    ),
+    body: Optional[str] = typer.Option(
+        None, "--body", "-B", help="JSON body or use '@file.json' to load from a file."
+    ),
+):
+    """
+    Run a saved endpoint.
+    
+    Examples:
+      - [cyan]oko run my_api -p id=123[/cyan]
+      - [cyan]oko run create_user -B '{"name":"Test"}'[/cyan]
+      - [cyan]oko run upload -B @data.json[/cyan]
+    """
+    if not config.find_config():
+        print_warning("No OKO configuration found. Run [secondary]oko init[/secondary] first.")
+        raise typer.Exit(1)
+
+    with console.status(f"[bold green]Running [primary]'{alias}'[/primary]...[/bold green]", spinner="dots"):
+        run_endpoint(alias, console, param, header, body)
+
+
+if __name__ == "__main__":
+    app()

oko_cli-0.1.0/oko/core/config.py

@@ -0,0 +1,132 @@
+import json
+from pathlib import Path
+from typing import Optional, Literal
+
+ConfigType = Literal["project", "global", "custom"]
+
+
+class OkoConfig:
+    def __init__(self):
+        self.config_type: Optional[ConfigType] = None
+        self.config_dir: Optional[Path] = None
+        self.config_file: Optional[Path] = None
+        self.endpoints_file: Optional[Path] = None
+
+    def find_config(self) -> bool:
+        """
+        Buscar configuración jerárquicamente:
+        1. Directorio actual o padres (.oko/)
+        2. Global (~/.oko/)
+        3. Si no existe, retornar False
+        """
+        # Buscar .oko/ en directorio actual o padres
+        current = Path.cwd()
+        for parent in [current] + list(current.parents):
+            oko_dir = parent / ".oko"
+            if oko_dir.exists() and (oko_dir / "config.json").exists():
+                self.config_type = "project"
+                self.config_dir = oko_dir
+                self.config_file = oko_dir / "config.json"
+                self.endpoints_file = oko_dir / "endpoints.json"
+                return True
+
+        # Buscar global
+        global_dir = Path.home() / ".oko"
+        if global_dir.exists() and (global_dir / "config.json").exists():
+            self.config_type = "global"
+            self.config_dir = global_dir
+            self.config_file = global_dir / "config.json"
+            self.endpoints_file = global_dir / "endpoints.json"
+            return True
+
+        return False
+
+    def load_config(self):
+        """Cargar configuración si existe"""
+        if self.config_file and self.config_file.exists():
+            try:
+                with open(self.config_file, "r", encoding="utf-8") as f:
+                    content = f.read()
+                    if not content.strip():
+                        return {"version": "1.0", "type": self.config_type or "unknown"}
+                    return json.loads(content)
+            except (json.JSONDecodeError, FileNotFoundError):
+                pass
+        return {"version": "1.0", "type": self.config_type or "unknown"}
+
+    def save_config(self, config_type: ConfigType, config_dir: Path, data: dict = None):
+        """Guardar nueva configuración"""
+        self.config_type = config_type
+        self.config_dir = config_dir
+        self.config_file = config_dir / "config.json"
+        self.endpoints_file = config_dir / "endpoints.json"
+
+        # Crear directorio
+        self.config_dir.mkdir(parents=True, exist_ok=True)
+
+        # Guardar config
+        config_data = {
+            "version": "1.0",
+            "type": config_type,
+            "created_at": data.get("created_at") if data else None,
+            "project_name": data.get("project_name") if data else None,
+        }
+
+        with open(self.config_file, "w", encoding="utf-8") as f:
+            json.dump(config_data, f, indent=2)
+
+        # Crear endpoints.json vacío si no existe
+        if not self.endpoints_file.exists():
+            with open(self.endpoints_file, "w", encoding="utf-8") as f:
+                json.dump({"endpoints": {}}, f, indent=2)
+
+    def get_endpoints_file(self) -> Path:
+        """Obtener archivo de endpoints (con fallback)"""
+        if self.endpoints_file and self.endpoints_file.exists():
+            return self.endpoints_file
+
+        # Si no hay config, usar global como fallback
+        if not self.find_config():
+            global_dir = Path.home() / ".oko"
+            global_dir.mkdir(parents=True, exist_ok=True)
+            return global_dir / "endpoints.json"
+
+        return self.endpoints_file
+
+
+# Instancia global
+config = OkoConfig()
+
+
+def ensure_config():
+    """Versión simple para compatibilidad"""
+    return config.get_endpoints_file().parent.mkdir(parents=True, exist_ok=True)
+
+
+def load_endpoints():
+    """Cargar endpoints desde la ubicación activa"""
+    endpoints_file = config.get_endpoints_file()
+
+    try:
+        if endpoints_file.exists():
+            with open(endpoints_file, "r", encoding="utf-8") as f:
+                content = f.read()
+                if not content.strip():
+                    return {"endpoints": {}}
+                return json.loads(content)
+    except (json.JSONDecodeError, FileNotFoundError) as e:
+        print(f"[yellow]⚠ Error loading endpoints: {e}. Creating new.[/yellow]")
+
+    # Crear nuevo si hay error
+    with open(endpoints_file, "w", encoding="utf-8") as f:
+        json.dump({"endpoints": {}}, f, indent=2)
+    return {"endpoints": {}}
+
+
+def save_endpoints(data: dict):
+    """Guardar endpoints en la ubicación activa"""
+    endpoints_file = config.get_endpoints_file()
+    endpoints_file.parent.mkdir(parents=True, exist_ok=True)
+
+    with open(endpoints_file, "w", encoding="utf-8") as f:
+        json.dump(data, f, indent=2)

oko_cli-0.1.0/oko/core/endpoints.py

@@ -0,0 +1,14 @@
+from .config import load_endpoints, save_endpoints
+
+
+def add_endpoint(alias: str, url: str, method: str = "GET"):
+    """Add a new endpoint using current config"""
+    data = load_endpoints()
+
+    endpoint_data = {
+        "url": url,
+        "method": method.upper(),
+    }
+
+    data["endpoints"][alias] = endpoint_data
+    save_endpoints(data)

oko_cli-0.1.0/oko/core/runner.py

@@ -0,0 +1,150 @@
+import httpx
+import json
+from urllib.parse import parse_qs, urlencode, urlparse, urlunparse
+from rich.console import Console
+from rich.pretty import Pretty
+from rich.table import Table
+from rich.panel import Panel
+from rich.box import ROUNDED
+
+from .config import load_endpoints
+from ..ui import print_error
+
+
+def _make_key_value_table(data: dict) -> Table:
+    """Creates a styled table for key-value data."""
+    table = Table(box=ROUNDED, show_header=False, border_style="secondary")
+    table.add_column("Key", style="info", no_wrap=True)
+    table.add_column("Value", style="white")
+    for key, value in data.items():
+        table.add_row(str(key), str(value))
+    return table
+
+
+def parse_params(param_list, console: Console):
+    """Convert ['a=1', 'b=2'] into {'a': '1', 'b': '2'}"""
+    params = {}
+    if not param_list:
+        return params
+    for item in param_list:
+        if "=" not in item:
+            console.print(f"[warning]Skipping invalid param:[/] {item}")
+            continue
+        key, value = item.split("=", 1)
+        params[key] = value
+    return params
+
+
+def parse_headers(header_list, console: Console):
+    """Convert headers list to dict"""
+    headers = {}
+    if not header_list:
+        return headers
+    for item in header_list:
+        if "=" not in item:
+            console.print(f"[warning]Skipping invalid header:[/] {item}")
+            continue
+        key, value = item.split("=", 1)
+        headers[key] = value
+    return headers
+
+
+def parse_body(body_data, console: Console):
+    """Parse JSON body from string or file"""
+    if not body_data:
+        return None
+
+    if body_data.startswith("@"):
+        filepath = body_data[1:]
+        try:
+            with open(filepath, "r") as f:
+                return json.load(f)
+        except Exception as e:
+            print_error(f"Error reading body file: {e}")
+            return None
+
+    try:
+        return json.loads(body_data)
+    except json.JSONDecodeError:
+        print_error(f"Invalid JSON body: {body_data}")
+        return None
+
+
+def merge_query_params(url, extra_params):
+    """Merge base URL query params with user-provided params"""
+    parsed = urlparse(url)
+    base_params = {k: v[0] for k, v in parse_qs(parsed.query).items()}
+    final_params = {**base_params, **extra_params}
+    new_query = urlencode(final_params)
+
+    return urlunparse(
+        (
+            parsed.scheme,
+            parsed.netloc,
+            parsed.path,
+            parsed.params,
+            new_query,
+            parsed.fragment,
+        )
+    )
+
+
+def run_endpoint(alias: str, console: Console, params=None, headers=None, body=None):
+    data = load_endpoints()
+    endpoints = data.get("endpoints", {})
+
+    if alias not in endpoints:
+        print_error(f"Endpoint '{alias}' not found.")
+        return
+
+    endpoint = endpoints[alias]
+    url = endpoint["url"]
+    method = endpoint["method"].upper()
+
+    # Parse inputs
+    extra_params = parse_params(params, console)
+    header_dict = parse_headers(headers, console)
+    body_data = parse_body(body, console)
+
+    # Merge URL params
+    final_url = merge_query_params(url, extra_params)
+
+    console.rule("[bold primary]Request[/bold primary]")
+    console.print(f"[bold]→ {method} {final_url}[/bold]")
+
+    if extra_params:
+        console.print(Panel(_make_key_value_table(extra_params), title="[info]Query Parameters[/info]", border_style="secondary"))
+
+    if header_dict:
+        console.print(Panel(_make_key_value_table(header_dict), title="[info]Headers[/info]", border_style="secondary"))
+
+    if body_data and method in ["POST", "PUT", "PATCH"]:
+        console.print(Panel(Pretty(body_data, expand_all=True), title="[info]Body[/info]", border_style="secondary"))
+
+    console.print()
+
+    try:
+        response = httpx.request(
+            method, final_url, headers=header_dict, json=body_data if body_data else None
+        )
+
+        status_style = "success" if response.is_success else "error"
+        console.rule(f"[bold {status_style}]Response[/bold {status_style}]")
+        console.print(f"\n[bold]Status:[/bold] [{status_style}]{response.status_code}[/]")
+
+        if response.headers:
+            console.print(Panel(_make_key_value_table(response.headers), title="[info]Headers[/info]", border_style="secondary"))
+
+        if response.content:
+            try:
+                json_data = response.json()
+                console.print(Panel(Pretty(json_data, expand_all=True), title="[info]Body[/info]", border_style="secondary"))
+            except Exception:
+                console.print(Panel(response.text[:2000], title="[warning]Response (Not JSON)[/warning]", border_style="warning"))
+        else:
+            console.print("\n[dim]No response body[/dim]")
+
+    except Exception as e:
+        print_error(f"Error connecting to endpoint: {e}")
+
+

oko_cli-0.1.0/oko/ui.py

@@ -0,0 +1,86 @@
+from rich.console import Console
+from rich.panel import Panel
+from rich.theme import Theme
+from rich.table import Table
+from rich.box import ROUNDED
+
+LOGO_CAT = """[bold blue]
+      /\\_/\\
+     ( o.o )
+      > ^ <
+[/bold blue]"""
+
+LOGO_OKO = """[bold bright_cyan]
+  ___  _  __  ___
+ / _ \| |/ / / _ \\
+| | | | ' / | | | |
+| |_| | . \\ | |_| |
+ \\___/|_|\\_\\ \\___/
+[/bold bright_cyan]"""
+
+
+# Custom theme for consistent styling
+custom_theme = Theme(
+    {
+        "info": "cyan",
+        "warning": "yellow",
+        "error": "bold red",
+        "success": "bold green",
+        "primary": "blue",
+        "secondary": "bright_cyan",
+    }
+)
+
+# Global console object
+console = Console(theme=custom_theme)
+
+
+def print_logo():
+    """Prints the OKO logo."""
+    console.print(LOGO_CAT, justify="center")
+    console.print(LOGO_OKO, justify="center")
+
+
+def print_success(message: str, title: str = "✅ Success"):
+    """Prints a success message in a panel."""
+    console.print(
+        Panel(
+            f"[success]{message}[/success]",
+            title=title,
+            border_style="success",
+            expand=False,
+        )
+    )
+
+
+def print_error(message: str, title: str = "❌ Error"):
+    """Prints an error message in a panel."""
+    console.print(
+        Panel(
+            f"[error]{message}[/error]", title=title, border_style="error", expand=False
+        )
+    )
+
+
+def print_warning(message: str, title: str = "⚠️ Warning"):
+    """Prints a warning message in a panel."""
+    console.print(
+        Panel(
+            f"[warning]{message}[/warning]",
+            title=title,
+            border_style="warning",
+            expand=False,
+        )
+    )
+
+
+def print_info_panel(message: str, title: str = "📋 Info"):
+    """Prints an info message in a panel."""
+    console.print(Panel(message, title=title, border_style="info", expand=False))
+
+
+def get_table() -> Table:
+    """Returns a nicely styled table."""
+    return Table(
+        show_header=True, header_style="bold bright_cyan", box=ROUNDED, padding=(0, 2)
+    )

oko_cli-0.1.0/pyproject.toml

@@ -0,0 +1,38 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "oko-cli"
+version = "0.1.0"
+description = "Elegant CLI for API endpoint testing"
+readme = "README.md"
+authors = [{ name = "Edward Ojeda", email = "edward.ojeda.es@gmail.com" }]
+license = { text = "MIT" }
+requires-python = ">=3.8"
+keywords = ["api", "cli", "testing", "http", "rest", "endpoints"]
+classifiers = [
+  "Development Status :: 4 - Beta",
+  "Intended Audience :: Developers",
+  "Topic :: Software Development :: Testing",
+  "License :: OSI Approved :: MIT License",
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3.8",
+  "Programming Language :: Python :: 3.9",
+  "Programming Language :: Python :: 3.10",
+  "Programming Language :: Python :: 3.11",
+  "Programming Language :: Python :: 3.12",
+  "Programming Language :: Python :: 3.13",
+]
+dependencies = ["httpx>=0.25.0", "typer>=0.9.0", "rich>=13.0.0"]
+
+[project.scripts]
+oko = "oko.cli:app"
+
+[project.urls]
+Homepage = "https://github.com/poll7872/oko"
+Repository = "https://github.com/tuusuario/oko"
+Issues = "https://github.com/poll7872/oko/issues"
+
+[tool.hatch.build]
+include = ["oko/**/*.py", "README.md", "LICENSE"]