zolvix-agent 0.3.0__tar.gz

zolvix_agent-0.3.0/PKG-INFO

@@ -0,0 +1,68 @@
+Metadata-Version: 2.4
+Name: zolvix-agent
+Version: 0.3.0
+Summary: Zolvix local file agent — connects your codebase to Zolvix AI
+Author: Zolvix
+License: MIT
+Project-URL: Homepage, https://zolvix.app
+Keywords: zolvix,ai,agent,rag,cli
+Classifier: Programming Language :: Python :: 3
+Classifier: Environment :: Console
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Software Development
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: websockets>=12.0
+Requires-Dist: watchdog>=4.0
+Requires-Dist: httpx>=0.27
+Requires-Dist: click>=8.1
+Requires-Dist: rich>=13.0
+Requires-Dist: pydantic>=2.0
+Requires-Dist: python-dotenv>=1.0
+Requires-Dist: aiofiles>=23.0
+Requires-Dist: pathspec>=0.12
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0; extra == "dev"
+
+# Zolvix Agent
+
+Command-line agent that lets Zolvix AI work with your local files.
+
+## Install
+
+```bash
+pip install zolvix-agent
+```
+
+## Usage
+
+```bash
+# 1. Log in (saves your API key)
+zolvix login
+
+# 2. Watch a project folder and connect it to Zolvix
+zolvix watch ./src
+
+# 3. Check your status
+zolvix status
+```
+
+Run `zolvix` with no command to see a quick getting-started guide, or
+`zolvix --help` for the full command reference.
+
+`zolvix watch` shows local file-change activity; the server-side change feed is
+not implemented yet.
+
+Use `--confirm-writes` to be asked before each file write.
+
+## Security
+
+- The agent only operates inside the folder you point it at (sandboxed).
+- `.env`, `*.key`, `*.pem`, `.git/`, `node_modules/`, `dist/`, and `build/` are
+  excluded from both reads and writes.
+- Every action is recorded in an audit log.
+
+## Requirements
+
+- Python 3.10+
+- A Business or Enterprise plan

zolvix_agent-0.3.0/README.md

@@ -0,0 +1,42 @@
+# Zolvix Agent
+
+Command-line agent that lets Zolvix AI work with your local files.
+
+## Install
+
+```bash
+pip install zolvix-agent
+```
+
+## Usage
+
+```bash
+# 1. Log in (saves your API key)
+zolvix login
+
+# 2. Watch a project folder and connect it to Zolvix
+zolvix watch ./src
+
+# 3. Check your status
+zolvix status
+```
+
+Run `zolvix` with no command to see a quick getting-started guide, or
+`zolvix --help` for the full command reference.
+
+`zolvix watch` shows local file-change activity; the server-side change feed is
+not implemented yet.
+
+Use `--confirm-writes` to be asked before each file write.
+
+## Security
+
+- The agent only operates inside the folder you point it at (sandboxed).
+- `.env`, `*.key`, `*.pem`, `.git/`, `node_modules/`, `dist/`, and `build/` are
+  excluded from both reads and writes.
+- Every action is recorded in an audit log.
+
+## Requirements
+
+- Python 3.10+
+- A Business or Enterprise plan

zolvix_agent-0.3.0/agent/__init__.py

@@ -0,0 +1,2 @@
+"""Zolvix Agent — local file agent for Zolvix AI."""
+__version__ = "0.3.0"

zolvix_agent-0.3.0/agent/config.py

@@ -0,0 +1,123 @@
+"""
+Agent configuration.
+Reads from ~/.zolvix/config or env vars or .zolvix file in project root.
+"""
+from __future__ import annotations
+import os
+import json
+from pathlib import Path
+from dataclasses import dataclass, field
+
+
+CONFIG_DIR  = Path.home() / ".zolvix"
+CONFIG_FILE = CONFIG_DIR / "config.json"
+DOTENV_FILE = Path(".zolvix")
+
+
+@dataclass
+class AgentConfig:
+    api_key:    str = ""
+    base_url:   str = "https://zolvix.app"  # prod default
+    watch_path: str = "."
+    # Hangi pattern'ler izlensin
+    include_patterns: list[str] = field(default_factory=lambda: [
+        "**/*.py", "**/*.ts", "**/*.tsx", "**/*.js", "**/*.jsx",
+        "**/*.java", "**/*.kt", "**/*.go", "**/*.rs",
+        "**/*.sql", "**/*.jrxml", "**/*.xml",
+        "**/*.json", "**/*.yaml", "**/*.yml",
+        "**/*.md", "**/*.txt",
+    ])
+    # Asla dokunulmasın
+    exclude_patterns: list[str] = field(default_factory=lambda: [
+        "**/.git/**", "**/__pycache__/**", "**/node_modules/**",
+        "**/.venv/**", "**/venv/**", "**/.env*",
+        "**/*.pyc", "**/*.pyo", "**/.next/**",
+        "**/dist/**", "**/build/**", "**/*.secret",
+        "**/*.key", "**/*.pem", "**/*.p12",
+    ])
+    # Maksimum dosya boyutu (byte) — büyük binary'leri atla
+    max_file_size: int = 512 * 1024  # 512 KB
+    # write_file için onay gereksin mi?
+    require_write_confirm: bool = False
+    # Optional callback invoked before a write when require_write_confirm is set.
+    # Returns True to proceed. Not loaded from disk/env (runtime-only).
+    confirm_cb: object = None
+
+    @property
+    def ws_url(self) -> str:
+        base = self.base_url.replace("https://", "wss://").replace("http://", "ws://")
+        return f"{base}/ws/agent"
+
+    @property
+    def api_url(self) -> str:
+        return self.base_url.rstrip("/")
+
+
+def load_config(
+    api_key:    str | None = None,
+    base_url:   str | None = None,
+    watch_path: str | None = None,
+) -> AgentConfig:
+    """
+    Config yükleme önceliği:
+    1. CLI argümanları (en yüksek)
+    2. Ortam değişkenleri
+    3. Proje .zolvix dosyası
+    4. ~/.zolvix/config.json
+    5. Defaults
+    """
+    cfg: dict = {}
+
+    # 4. Global config
+    if CONFIG_FILE.exists():
+        try:
+            cfg.update(json.loads(CONFIG_FILE.read_text()))
+        except Exception:
+            pass
+
+    # field-name aliases shared by .zolvix and env vars
+    _alias = {"zolvix_api_key": "api_key", "zolvix_base_url": "base_url", "zolvix_watch": "watch_path"}
+
+    # 3. Proje .zolvix
+    if DOTENV_FILE.exists():
+        try:
+            for line in DOTENV_FILE.read_text().splitlines():
+                line = line.strip()
+                if "=" in line and not line.startswith("#"):
+                    k, v = line.split("=", 1)
+                    key = k.strip().lower()
+                    cfg[_alias.get(key, key)] = v.strip()
+        except Exception:
+            pass
+
+    # 2. Env vars
+    env_map = {
+        "ZOLVIX_API_KEY":  "api_key",
+        "ZOLVIX_BASE_URL": "base_url",
+        "ZOLVIX_WATCH":    "watch_path",
+    }
+    for env_key, cfg_key in env_map.items():
+        val = os.environ.get(env_key)
+        if val:
+            cfg[cfg_key] = val
+
+    # 1. CLI args
+    if api_key:    cfg["api_key"]    = api_key
+    if base_url:   cfg["base_url"]   = base_url
+    if watch_path: cfg["watch_path"] = watch_path
+
+    return AgentConfig(**{k: v for k, v in cfg.items() if hasattr(AgentConfig, k)})
+
+
+def save_config(api_key: str, base_url: str = "https://zolvix.app") -> None:
+    """~/.zolvix/config.json'a kaydet."""
+    CONFIG_DIR.mkdir(parents=True, exist_ok=True)
+    existing = {}
+    if CONFIG_FILE.exists():
+        try:
+            existing = json.loads(CONFIG_FILE.read_text())
+        except Exception:
+            pass
+    existing.update({"api_key": api_key, "base_url": base_url})
+    CONFIG_FILE.write_text(json.dumps(existing, indent=2))
+    CONFIG_FILE.chmod(0o600)  # sadece kullanıcı okusun

zolvix_agent-0.3.0/agent/main.py

@@ -0,0 +1,304 @@
+"""
+Zolvix Agent CLI
+zolvix watch ./src
+zolvix login
+zolvix status
+"""
+from __future__ import annotations
+import asyncio
+import sys
+import os
+import json
+import signal
+import logging
+from datetime import datetime
+from pathlib import Path
+
+import click
+import httpx
+from rich.console import Console
+from rich.panel import Panel
+from rich.text import Text
+from rich.live import Live
+from rich.table import Table
+from rich import print as rprint
+
+from agent import __version__
+from agent.config import AgentConfig, load_config, save_config
+from agent.tools import ToolExecutor
+from agent.ws_client import AgentWebSocket
+from agent.watcher import FileWatcher
+
+console = Console()
+log     = logging.getLogger("zolvix")
+
+
+# ── CLI ────────────────────────────────────────────────────────────────────────
+
+@click.group(invoke_without_command=True)
+@click.option("--debug", is_flag=True, help="Enable debug logging.")
+@click.pass_context
+def cli(ctx: click.Context, debug: bool):
+    """Zolvix Agent - connect your local code to Zolvix AI."""
+    level = logging.DEBUG if debug else logging.WARNING
+    logging.basicConfig(level=level, format="%(message)s")
+    if ctx.invoked_subcommand is None:
+        _print_welcome()
+
+
+@cli.command()
+@click.option("--api-key", envvar="ZOLVIX_API_KEY", help="Your Zolvix API key")
+@click.option("--base-url", default="https://zolvix.app", help="Zolvix server URL")
+def login(api_key: str, base_url: str):
+    """Save your Zolvix API key."""
+    if not api_key:
+        api_key = click.prompt("Zolvix API Key", hide_input=True)
+
+    console.print("[dim]Testing connection...[/]")
+    try:
+        r = httpx.get(
+            f"{base_url.rstrip('/')}/api/auth/me",
+            headers={"Authorization": f"Bearer {api_key}"},
+            timeout=10,
+        )
+        if r.status_code == 401:
+            console.print("[red]Invalid API key.[/]")
+            sys.exit(1)
+        r.raise_for_status()
+        data = r.json()
+        save_config(api_key, base_url)
+        console.print(Panel(
+            f"[green]Logged in![/]\n\n"
+            f"[dim]Email:[/] {data.get('email', '?')}\n"
+            f"[dim]Plan:[/] {data.get('plan', '?')}\n"
+            f"[dim]Config:[/] ~/.zolvix/config.json",
+            title="[bold]Zolvix Agent[/]",
+            border_style="green",
+        ))
+    except httpx.RequestError as e:
+        console.print(f"[red]Connection error: {e}[/]")
+        sys.exit(1)
+
+
+@cli.command()
+@click.argument("path", default=".", type=click.Path(exists=True))
+@click.option("--api-key",  envvar="ZOLVIX_API_KEY")
+@click.option("--base-url", envvar="ZOLVIX_BASE_URL")
+@click.option("--confirm-writes", is_flag=True, help="Ask for confirmation before each file write.")
+def watch(path: str, api_key: str | None, base_url: str | None, confirm_writes: bool):
+    """Watch a folder and connect it to Zolvix."""
+    config = load_config(
+        api_key=api_key,
+        base_url=base_url,
+        watch_path=str(Path(path).resolve()),
+    )
+    config.require_write_confirm = confirm_writes
+
+    if not config.api_key:
+        console.print("[red]No API key found. Run 'zolvix login' first.[/]")
+        sys.exit(1)
+
+    _check_plan(config)
+
+    console.print(Panel(
+        f"[bold cyan]Zolvix Agent[/] [dim]v{__version__}[/]\n\n"
+        f"[dim]Watching:[/] [green]{config.watch_path}[/]\n"
+        f"[dim]Server:[/] {config.base_url}\n\n"
+        f"[dim]Stop with Ctrl+C[/]",
+        border_style="cyan",
+    ))
+
+    executor = ToolExecutor(config)
+
+    if config.require_write_confirm:
+        def _confirm(path: str, diff: str) -> bool:
+            console.print(f"[yellow]write_file -> {path}[/]")
+            return click.confirm("Allow this file write?", default=False)
+        config.confirm_cb = _confirm
+
+    activity: list[dict] = []
+
+    def on_status(level: str, msg: str):
+        ts = datetime.now().strftime("%H:%M:%S")
+        color_map = {
+            "info":    "dim",
+            "success": "green",
+            "warn":    "yellow",
+            "error":   "red",
+            "tool":    "cyan",
+            "ok":      "green",
+            "agent":   "purple",
+        }
+        color = color_map.get(level, "white")
+        icon_map = {
+            "info":    "●",
+            "success": "✓",
+            "warn":    "⚠",
+            "error":   "✗",
+            "tool":    "⚙",
+            "ok":      "✓",
+            "agent":   "🤖",
+        }
+        icon = icon_map.get(level, "·")
+        console.print(f"[dim]{ts}[/] [{color}]{icon}[/] {msg}")
+        activity.append({"ts": ts, "level": level, "msg": msg})
+
+    def on_file_change(event: str, src: str, dst: str | None):
+        on_status("info", f"File {event}: {src}")
+
+    watcher = FileWatcher(config, on_file_change)
+    watcher.start()
+
+    ws = AgentWebSocket(config, executor, on_status)
+    loop = asyncio.new_event_loop()
+    asyncio.set_event_loop(loop)
+    stop_event = asyncio.Event()
+
+    async def _run():
+        runner = loop.create_task(ws.run())
+        await stop_event.wait()
+        await ws.stop()
+        runner.cancel()
+        try:
+            await runner
+        except asyncio.CancelledError:
+            pass
+
+    def _shutdown(sig, frame):
+        console.print("\n[dim]Shutting down...[/]")
+        loop.call_soon_threadsafe(stop_event.set)
+
+    signal.signal(signal.SIGINT, _shutdown)
+    try:
+        signal.signal(signal.SIGTERM, _shutdown)
+    except (ValueError, AttributeError):
+        pass  # SIGTERM not available on this platform
+
+    try:
+        loop.run_until_complete(_run())
+    finally:
+        watcher.stop()
+        loop.close()
+        console.print("[dim]Agent stopped.[/]")
+
+
+@cli.command()
+@click.option("--api-key", envvar="ZOLVIX_API_KEY")
+@click.option("--base-url", envvar="ZOLVIX_BASE_URL")
+def status(api_key: str | None, base_url: str | None):
+    """Show your connection and plan status."""
+    config = load_config(api_key=api_key, base_url=base_url)
+
+    if not config.api_key:
+        console.print("[red]No API key found. Run 'zolvix login'.[/]")
+        return
+
+    try:
+        r = httpx.get(
+            f"{config.api_url}/api/auth/me",
+            headers={"Authorization": f"Bearer {config.api_key}"},
+            timeout=10,
+        )
+        r.raise_for_status()
+        data = r.json()
+
+        table = Table(show_header=False, box=None, padding=(0, 2))
+        table.add_row("[dim]Email[/]",   data.get("email", "?"))
+        table.add_row("[dim]Plan[/]",    data.get("plan", "?"))
+        table.add_row("[dim]Server[/]",  config.base_url)
+        table.add_row("[dim]Config[/]",  str(Path.home() / ".zolvix" / "config.json"))
+
+        plan = data.get("plan", "")
+        if plan in ("business", "enterprise"):
+            status_text = "[green]✓ Agent mode available[/]"
+        else:
+            status_text = f"[yellow]⚠ Agent mode requires a Business or Enterprise plan (current: {plan})[/]"
+
+        console.print(Panel(table, title="[bold]Zolvix Agent Status[/]", border_style="cyan"))
+        console.print(status_text)
+
+    except httpx.RequestError as e:
+        console.print(f"[red]Connection error: {e}[/]")
+    except httpx.HTTPStatusError as e:
+        console.print(f"[red]HTTP error: {e.response.status_code}[/]")
+
+
+@cli.command()
+@click.argument("path", default=".", type=click.Path(exists=True))
+@click.option("--api-key", envvar="ZOLVIX_API_KEY")
+def init(path: str, api_key: str | None):
+    """Create a .zolvix config file in a project folder."""
+    config = load_config(api_key=api_key, watch_path=path)
+    dotenv = Path(path) / ".zolvix"
+
+    content = f"""# Zolvix Agent config - add this file to .gitignore!
+ZOLVIX_API_KEY={config.api_key or 'your-api-key-here'}
+ZOLVIX_BASE_URL={config.base_url}
+"""
+    dotenv.write_text(content)
+
+    gitignore = Path(path) / ".gitignore"
+    if gitignore.exists():
+        gi = gitignore.read_text()
+        if ".zolvix" not in gi:
+            gitignore.write_text(gi + "\n.zolvix\n")
+            console.print("[green]✓ Added .zolvix to .gitignore[/]")
+
+    console.print(f"[green]✓ Created {dotenv}[/]")
+    console.print("[dim]Add your API key to the file, then run 'zolvix watch'.[/]")
+
+
+# ── Helpers ────────────────────────────────────────────────────────────────────
+
+def _print_welcome() -> None:
+    """Friendly getting-started banner for a bare `zolvix` invocation.
+    Local-only: adapts to whether the user has logged in (config exists)."""
+    from agent.config import CONFIG_FILE
+    logged_in = CONFIG_FILE.exists()
+    step1_tag = "[green]logged in[/]" if logged_in else "[yellow](start here)[/]"
+    step2_tag = "  [yellow]<- next[/]" if logged_in else ""
+    body = Text.from_markup(
+        "Connect your local code to Zolvix AI.\n\n"
+        "[bold]Get started:[/]\n"
+        f"  [cyan]1[/]  [bold]zolvix login[/]      Save your API key            {step1_tag}\n"
+        f"  [cyan]2[/]  [bold]zolvix watch .[/]    Watch this folder and connect{step2_tag}\n"
+        "  [cyan]3[/]  Open Zolvix in your browser, turn on Agent mode, and chat\n\n"
+        "[bold]More:[/]\n"
+        "  [dim]zolvix status[/]      Show connection and plan\n"
+        "  [dim]zolvix init[/]        Create a .zolvix config file here\n"
+        "  [dim]zolvix --help[/]      Full command reference\n\n"
+        "[dim]Docs: https://zolvix.app  -  Needs a Business or Enterprise plan[/]"
+    )
+    console.print(Panel(
+        body,
+        title=f"[bold cyan]Zolvix Agent[/] [dim]v{__version__}[/]",
+        border_style="cyan",
+    ))
+
+
+def _check_plan(config: AgentConfig) -> None:
+    """Business+ plan check."""
+    try:
+        r = httpx.get(
+            f"{config.api_url}/api/auth/me",
+            headers={"Authorization": f"Bearer {config.api_key}"},
+            timeout=10,
+        )
+        if r.status_code == 401:
+            console.print("[red]Invalid API key.[/]")
+            sys.exit(1)
+        data = r.json()
+        plan = data.get("plan", "")
+        if plan not in ("business", "enterprise"):
+            console.print(
+                f"[yellow]⚠ Agent mode requires a Business or Enterprise plan.[/]\n"
+                f"[dim]Current plan: {plan}[/]\n"
+                f"Upgrade at: {config.base_url}/pricing"
+            )
+            sys.exit(1)
+    except httpx.RequestError:
+        console.print("[yellow]⚠ Could not verify plan, continuing...[/]")
+
+
+if __name__ == "__main__":
+    cli()

zolvix_agent-0.3.0/agent/patterns.py

@@ -0,0 +1,28 @@
+"""Single source of include/exclude path matching.
+
+Uses gitignore semantics (pathspec) so patterns like ``**/*.py`` match files at
+every depth INCLUDING the watch root, and ``**/.git/**`` / ``*.key`` exclusions
+fire at any depth. fnmatch could not express ``**`` and silently broke both.
+"""
+from __future__ import annotations
+
+import pathspec
+
+
+class PathMatcher:
+    def __init__(self, include: list[str], exclude: list[str]):
+        self._include = pathspec.PathSpec.from_lines("gitwildmatch", include)
+        self._exclude = pathspec.PathSpec.from_lines("gitwildmatch", exclude)
+
+    def excluded(self, rel: str) -> bool:
+        rel = rel.replace("\\", "/")
+        return self._exclude.match_file(rel)
+
+    def allowed(self, rel: str) -> bool:
+        """Visible unless excluded. Include patterns are NOT a hard gate — file
+        discovery must surface everything that exists, extensioned or not
+        (e.g. ``Makefile``, ``Dockerfile``, a bare ``mehmet``). Secrets/junk
+        stay blocked by the exclude list; ``read_file`` still guards by size and
+        decodes with ``errors='replace'`` so binaries can't crash a read."""
+        rel = rel.replace("\\", "/")
+        return not self._exclude.match_file(rel)