zyora-cli 0.1.0__py3-none-any.whl

zyora/__init__.py

@@ -0,0 +1,4 @@
+"""Zyora CLI - AI-powered code generation and security scanning."""
+
+__version__ = "0.1.0"
+__app_name__ = "zyora"

zyora/__main__.py

@@ -0,0 +1,6 @@
+"""Entry point for running zyora as a module."""
+
+from .main import app
+
+if __name__ == "__main__":
+    app()

zyora/client.py

@@ -0,0 +1,194 @@
+"""Zyora API client with streaming support."""
+
+import json
+from typing import AsyncIterator, Iterator, Optional
+import httpx
+from pydantic import BaseModel
+
+from .config import load_config, get_api_key
+
+
+class Message(BaseModel):
+    """Chat message."""
+
+    role: str
+    content: str
+
+
+class ChatResponse(BaseModel):
+    """Chat completion response."""
+
+    id: str
+    model: str
+    content: str
+    finish_reason: Optional[str] = None
+    usage: Optional[dict] = None
+
+
+class ZyoraClient:
+    """Zyora API client."""
+
+    def __init__(
+        self,
+        api_key: Optional[str] = None,
+        api_base: Optional[str] = None,
+        model: Optional[str] = None,
+        timeout: float = 120.0,
+    ):
+        self.config = load_config()
+        self.api_key = api_key or get_api_key()
+        self.api_base = api_base or self.config.api_base
+        self.model = model or self.config.model
+        self.timeout = timeout
+
+        if not self.api_key:
+            raise ValueError(
+                "API key not found. Set ZYORA_API_KEY or run 'zyora config set api_key <key>'"
+            )
+
+    def _get_headers(self) -> dict:
+        """Get request headers."""
+        return {
+            "Authorization": f"Bearer {self.api_key}",
+            "Content-Type": "application/json",
+        }
+
+    def chat(
+        self,
+        messages: list[Message],
+        max_tokens: Optional[int] = None,
+        temperature: Optional[float] = None,
+        stream: bool = False,
+    ) -> ChatResponse | Iterator[str]:
+        """Send a chat completion request."""
+        url = f"{self.api_base}/v1/chat/completions"
+
+        payload = {
+            "model": self.model,
+            "messages": [m.model_dump() for m in messages],
+            "max_tokens": max_tokens or self.config.max_tokens,
+            "temperature": temperature or self.config.temperature,
+            "stream": stream,
+        }
+
+        if stream:
+            return self._stream_chat(url, payload)
+        else:
+            return self._sync_chat(url, payload)
+
+    def _sync_chat(self, url: str, payload: dict) -> ChatResponse:
+        """Synchronous chat completion."""
+        with httpx.Client(timeout=self.timeout) as client:
+            response = client.post(url, headers=self._get_headers(), json=payload)
+            response.raise_for_status()
+            data = response.json()
+
+            # Handle potential response format variations
+            if "choices" not in data or not data["choices"]:
+                raise ValueError(f"Invalid response format: {data}")
+
+            choice = data["choices"][0]
+            content = ""
+
+            if "message" in choice:
+                content = choice["message"].get("content", "")
+            elif "text" in choice:
+                content = choice["text"]
+
+            return ChatResponse(
+                id=data.get("id", ""),
+                model=data.get("model", self.model),
+                content=content,
+                finish_reason=choice.get("finish_reason"),
+                usage=data.get("usage"),
+            )
+
+    def _stream_chat(self, url: str, payload: dict) -> Iterator[str]:
+        """Streaming chat completion."""
+        with httpx.Client(timeout=self.timeout) as client:
+            with client.stream(
+                "POST", url, headers=self._get_headers(), json=payload
+            ) as response:
+                response.raise_for_status()
+                for line in response.iter_lines():
+                    if line.startswith("data: "):
+                        data_str = line[6:]
+                        if data_str.strip() == "[DONE]":
+                            break
+                        try:
+                            data = json.loads(data_str)
+                            if "choices" in data and data["choices"]:
+                                delta = data["choices"][0].get("delta", {})
+                                if "content" in delta:
+                                    yield delta["content"]
+                        except json.JSONDecodeError:
+                            continue
+
+    async def achat(
+        self,
+        messages: list[Message],
+        max_tokens: Optional[int] = None,
+        temperature: Optional[float] = None,
+        stream: bool = False,
+    ) -> ChatResponse | AsyncIterator[str]:
+        """Async chat completion request."""
+        url = f"{self.api_base}/v1/chat/completions"
+
+        payload = {
+            "model": self.model,
+            "messages": [m.model_dump() for m in messages],
+            "max_tokens": max_tokens or self.config.max_tokens,
+            "temperature": temperature or self.config.temperature,
+            "stream": stream,
+        }
+
+        if stream:
+            return self._async_stream_chat(url, payload)
+        else:
+            return await self._async_chat(url, payload)
+
+    async def _async_chat(self, url: str, payload: dict) -> ChatResponse:
+        """Async synchronous chat completion."""
+        async with httpx.AsyncClient(timeout=self.timeout) as client:
+            response = await client.post(url, headers=self._get_headers(), json=payload)
+            response.raise_for_status()
+            data = response.json()
+
+            return ChatResponse(
+                id=data.get("id", ""),
+                model=data.get("model", self.model),
+                content=data["choices"][0]["message"]["content"],
+                finish_reason=data["choices"][0].get("finish_reason"),
+                usage=data.get("usage"),
+            )
+
+    async def _async_stream_chat(self, url: str, payload: dict) -> AsyncIterator[str]:
+        """Async streaming chat completion."""
+        async with httpx.AsyncClient(timeout=self.timeout) as client:
+            async with client.stream(
+                "POST", url, headers=self._get_headers(), json=payload
+            ) as response:
+                response.raise_for_status()
+                async for line in response.aiter_lines():
+                    if line.startswith("data: "):
+                        data_str = line[6:]
+                        if data_str.strip() == "[DONE]":
+                            break
+                        try:
+                            data = json.loads(data_str)
+                            if "choices" in data and data["choices"]:
+                                delta = data["choices"][0].get("delta", {})
+                                if "content" in delta:
+                                    yield delta["content"]
+                        except json.JSONDecodeError:
+                            continue
+
+    def list_models(self) -> list[dict]:
+        """List available models."""
+        url = f"{self.api_base}/v1/models"
+
+        with httpx.Client(timeout=30.0) as client:
+            response = client.get(url, headers=self._get_headers())
+            response.raise_for_status()
+            data = response.json()
+            return data.get("data", [])

zyora/commands/__init__.py

@@ -0,0 +1 @@
+"""Zyora CLI commands."""

zyora/commands/config_cmd.py

@@ -0,0 +1,106 @@
+"""Configuration commands."""
+
+from typing import Optional
+import typer
+from rich.table import Table
+
+from ..config import load_config, save_config, get_config_path, ZyoraConfig
+from ..utils.display import console, print_success, print_error
+
+app = typer.Typer(help="Configuration management")
+
+
+@app.command("show")
+def show_config():
+    """Show current configuration."""
+    config = load_config()
+    config_path = get_config_path()
+
+    console.print(f"\n[bold green]Configuration File:[/] {config_path}\n")
+
+    table = Table(title="Zyora Configuration", border_style="green")
+    table.add_column("Setting", style="cyan")
+    table.add_column("Value", style="white")
+
+    config_dict = config.model_dump()
+    for key, value in config_dict.items():
+        # Mask API key
+        if key == "api_key" and value:
+            display_value = f"{value[:8]}...{value[-4:]}" if len(value) > 12 else "***"
+        elif isinstance(value, list):
+            display_value = ", ".join(value[:5]) + ("..." if len(value) > 5 else "")
+        else:
+            display_value = str(value)
+        table.add_row(key, display_value)
+
+    console.print(table)
+
+
+@app.command("set")
+def set_config(
+    key: str = typer.Argument(..., help="Configuration key"),
+    value: str = typer.Argument(..., help="Configuration value"),
+):
+    """Set a configuration value."""
+    config = load_config()
+
+    # Validate key
+    valid_keys = ["api_key", "api_base", "model", "max_tokens", "temperature", "stream", "theme"]
+    if key not in valid_keys:
+        print_error(f"Invalid key: {key}\nValid keys: {', '.join(valid_keys)}")
+        raise typer.Exit(1)
+
+    # Convert value types
+    if key == "max_tokens":
+        value = int(value)
+    elif key == "temperature":
+        value = float(value)
+    elif key == "stream":
+        value = value.lower() in ("true", "1", "yes")
+
+    # Update config
+    setattr(config, key, value)
+    save_config(config)
+
+    print_success(f"Set {key} = {value if key != 'api_key' else '***'}")
+
+
+@app.command("get")
+def get_config(key: str = typer.Argument(..., help="Configuration key")):
+    """Get a configuration value."""
+    config = load_config()
+
+    if not hasattr(config, key):
+        print_error(f"Unknown configuration key: {key}")
+        raise typer.Exit(1)
+
+    value = getattr(config, key)
+
+    # Mask API key
+    if key == "api_key" and value:
+        value = f"{value[:8]}...{value[-4:]}" if len(value) > 12 else "***"
+
+    console.print(f"[cyan]{key}[/]: {value}")
+
+
+@app.command("reset")
+def reset_config(
+    confirm: bool = typer.Option(False, "--yes", "-y", help="Skip confirmation"),
+):
+    """Reset configuration to defaults."""
+    if not confirm:
+        confirm = typer.confirm("Reset all configuration to defaults?")
+
+    if confirm:
+        config = ZyoraConfig()
+        save_config(config)
+        print_success("Configuration reset to defaults")
+    else:
+        console.print("[dim]Cancelled[/]")
+
+
+@app.command("path")
+def show_path():
+    """Show configuration file path."""
+    config_path = get_config_path()
+    console.print(f"[cyan]Config path:[/] {config_path}")

zyora/commands/scan.py

@@ -0,0 +1,188 @@
+"""Security scanning commands."""
+
+from pathlib import Path
+from typing import Optional
+import typer
+from rich.progress import Progress, SpinnerColumn, TextColumn
+from rich.table import Table
+from rich.panel import Panel
+
+from ..client import ZyoraClient, Message
+from ..config import load_config
+from ..utils.display import console, print_error, print_success, print_warning
+
+app = typer.Typer(help="Security scanning commands")
+
+
+SCAN_PROMPT = """You are a security expert. Analyze the following code for security vulnerabilities.
+
+For each vulnerability found, provide:
+1. **Vulnerability Type** (e.g., SQL Injection, XSS, Command Injection)
+2. **CWE ID** (e.g., CWE-89)
+3. **Severity** (Critical, High, Medium, Low)
+4. **Location** (file and line number if possible)
+5. **Description** of the vulnerability
+6. **Remediation** - how to fix it
+7. **Fixed Code** - provide the corrected code snippet
+
+If no vulnerabilities are found, state that the code appears secure but recommend:
+- Regular security audits
+- Following security best practices
+- Using security linters
+
+Be thorough but avoid false positives. Only report actual security issues.
+
+Code to analyze:
+"""
+
+
+def scan_file(file_path: Path, client: ZyoraClient) -> Optional[str]:
+    """Scan a single file for vulnerabilities."""
+    try:
+        content = file_path.read_text(encoding="utf-8", errors="ignore")
+    except Exception as e:
+        return f"Error reading file: {e}"
+
+    if not content.strip():
+        return "File is empty"
+
+    prompt = f"{SCAN_PROMPT}\n\n```{file_path.suffix[1:] if file_path.suffix else 'text'}\n# File: {file_path.name}\n{content}\n```"
+
+    messages = [Message(role="user", content=prompt)]
+
+    try:
+        response = client.chat(messages, stream=False, temperature=0.1)
+        return response.content
+    except Exception as e:
+        return f"Error during scan: {e}"
+
+
+@app.command("file")
+def scan_single_file(
+    file_path: Path = typer.Argument(..., help="Path to file to scan"),
+    output: Optional[Path] = typer.Option(None, "--output", "-o", help="Save results to file"),
+):
+    """Scan a single file for security vulnerabilities."""
+    if not file_path.exists():
+        print_error(f"File not found: {file_path}")
+        raise typer.Exit(1)
+
+    config = load_config()
+    if not config.api_key:
+        print_error("API key not configured. Run 'zyora config set api_key <key>'")
+        raise typer.Exit(1)
+
+    console.print(f"\n[bold green]Scanning:[/] {file_path}\n")
+
+    try:
+        client = ZyoraClient()
+    except ValueError as e:
+        print_error(str(e))
+        raise typer.Exit(1)
+
+    with Progress(
+        SpinnerColumn(style="green"),
+        TextColumn("[progress.description]{task.description}"),
+        console=console,
+    ) as progress:
+        progress.add_task("Analyzing code for vulnerabilities...", total=None)
+        result = scan_file(file_path, client)
+
+    if result:
+        console.print(Panel(result, title=f"[bold green]Scan Results: {file_path.name}[/]", border_style="green"))
+
+        if output:
+            output.write_text(result)
+            print_success(f"Results saved to {output}")
+    else:
+        print_warning("No results returned from scan")
+
+
+@app.command("dir")
+def scan_directory(
+    directory: Path = typer.Argument(Path("."), help="Directory to scan"),
+    recursive: bool = typer.Option(True, "--recursive", "-r", help="Scan recursively"),
+    extensions: Optional[str] = typer.Option(None, "--ext", "-e", help="File extensions (comma-separated)"),
+    output: Optional[Path] = typer.Option(None, "--output", "-o", help="Save results to file"),
+    max_files: int = typer.Option(20, "--max-files", "-m", help="Maximum files to scan"),
+):
+    """Scan a directory for security vulnerabilities."""
+    if not directory.exists():
+        print_error(f"Directory not found: {directory}")
+        raise typer.Exit(1)
+
+    config = load_config()
+    if not config.api_key:
+        print_error("API key not configured. Run 'zyora config set api_key <key>'")
+        raise typer.Exit(1)
+
+    # Get file extensions to scan
+    if extensions:
+        exts = [f".{e.strip().lstrip('.')}" for e in extensions.split(",")]
+    else:
+        exts = config.scan_extensions
+
+    # Find files to scan
+    files_to_scan = []
+    pattern = "**/*" if recursive else "*"
+
+    for path in directory.glob(pattern):
+        if path.is_file() and path.suffix in exts:
+            # Skip common ignore patterns
+            path_str = str(path)
+            if any(ignore in path_str for ignore in ["node_modules", "__pycache__", ".git", "venv", ".venv"]):
+                continue
+            files_to_scan.append(path)
+            if len(files_to_scan) >= max_files:
+                break
+
+    if not files_to_scan:
+        print_warning(f"No files found with extensions: {', '.join(exts)}")
+        raise typer.Exit(0)
+
+    console.print(f"\n[bold green]Found {len(files_to_scan)} files to scan[/]\n")
+
+    # Show files table
+    table = Table(title="Files to Scan", border_style="green")
+    table.add_column("File", style="cyan")
+    table.add_column("Size", style="dim")
+    for f in files_to_scan:
+        table.add_row(str(f.relative_to(directory)), f"{f.stat().st_size:,} bytes")
+    console.print(table)
+    console.print()
+
+    try:
+        client = ZyoraClient()
+    except ValueError as e:
+        print_error(str(e))
+        raise typer.Exit(1)
+
+    results = []
+    with Progress(
+        SpinnerColumn(style="green"),
+        TextColumn("[progress.description]{task.description}"),
+        console=console,
+    ) as progress:
+        task = progress.add_task("Scanning files...", total=len(files_to_scan))
+
+        for file_path in files_to_scan:
+            progress.update(task, description=f"Scanning {file_path.name}...")
+            result = scan_file(file_path, client)
+            results.append((file_path, result))
+            progress.advance(task)
+
+    # Display results
+    all_results = []
+    for file_path, result in results:
+        console.print(Panel(
+            result or "No results",
+            title=f"[bold green]{file_path.relative_to(directory)}[/]",
+            border_style="green"
+        ))
+        all_results.append(f"## {file_path}\n\n{result}\n\n---\n")
+
+    if output:
+        output.write_text("\n".join(all_results))
+        print_success(f"Results saved to {output}")
+
+    print_success(f"Scanned {len(files_to_scan)} files")

zyora/config.py

@@ -0,0 +1,97 @@
+"""Configuration management for Zyora CLI."""
+
+import os
+from pathlib import Path
+from typing import Optional
+import toml
+from pydantic import BaseModel, Field
+
+
+class ZyoraConfig(BaseModel):
+    """Zyora CLI configuration."""
+
+    api_key: Optional[str] = Field(default=None, description="Zyora API key")
+    api_base: str = Field(default="https://app.zyoralabs.com", description="API base URL")
+    model: str = Field(default="Zyora-DEV-32B", description="Model to use")
+    max_tokens: int = Field(default=16384, description="Maximum tokens for response")
+    temperature: float = Field(default=0.7, description="Temperature for generation")
+    stream: bool = Field(default=True, description="Stream responses for real-time output")
+    theme: str = Field(default="monokai", description="Syntax highlighting theme")
+
+    # Context settings
+    max_context_files: int = Field(default=10, description="Max files to include in context")
+    max_file_size: int = Field(default=100000, description="Max file size to read (bytes)")
+
+    # Security scan settings
+    scan_extensions: list[str] = Field(
+        default=[".py", ".js", ".ts", ".jsx", ".tsx", ".go", ".rs", ".java", ".php", ".rb", ".c", ".cpp", ".h"],
+        description="File extensions to scan"
+    )
+
+
+def get_config_dir() -> Path:
+    """Get the configuration directory."""
+    if os.name == "nt":
+        config_dir = Path(os.environ.get("APPDATA", "~")) / "zyora"
+    else:
+        config_dir = Path.home() / ".config" / "zyora"
+    config_dir.mkdir(parents=True, exist_ok=True)
+    return config_dir
+
+
+def get_config_path() -> Path:
+    """Get the configuration file path."""
+    return get_config_dir() / "config.toml"
+
+
+def load_config() -> ZyoraConfig:
+    """Load configuration from file and environment."""
+    config_path = get_config_path()
+    config_data = {}
+
+    # Load from file if exists
+    if config_path.exists():
+        try:
+            config_data = toml.load(config_path)
+        except Exception:
+            pass
+
+    # Override with environment variables
+    env_mappings = {
+        "ZYORA_API_KEY": "api_key",
+        "ZYORA_API_BASE": "api_base",
+        "ZYORA_MODEL": "model",
+        "ZYORA_MAX_TOKENS": "max_tokens",
+        "ZYORA_TEMPERATURE": "temperature",
+    }
+
+    for env_var, config_key in env_mappings.items():
+        if env_var in os.environ:
+            value = os.environ[env_var]
+            if config_key in ("max_tokens",):
+                value = int(value)
+            elif config_key in ("temperature",):
+                value = float(value)
+            config_data[config_key] = value
+
+    return ZyoraConfig(**config_data)
+
+
+def save_config(config: ZyoraConfig) -> None:
+    """Save configuration to file."""
+    config_path = get_config_path()
+    config_data = config.model_dump(exclude_none=True)
+
+    with open(config_path, "w") as f:
+        toml.dump(config_data, f)
+
+
+def get_api_key() -> Optional[str]:
+    """Get API key from config or environment."""
+    # Check environment first
+    if "ZYORA_API_KEY" in os.environ:
+        return os.environ["ZYORA_API_KEY"]
+
+    # Check config file
+    config = load_config()
+    return config.api_key