feat: PyPI-ready package structure (v0.2.0)

- Reorganize code into agentzero_cli package
- Fix relative imports for pip install compatibility
- Add prompt-toolkit to dependencies
- Update backend initialization to use get_backend() factory
- Add docs/PUBLISHING.md with PyPI upload instructions
- Build passes: twine check dist/* PASSED

Ready for: pip install agentzero-cli
Commands: a0, a0tui, a0cli, agentzero

Author: vizi2000

agentzero_cli/__init__.py

@@ -0,0 +1,15 @@
+"""
+AgentZero CLI - AI coding agent with security interceptor.
+
+A TUI/CLI tool for AI-assisted coding with:
+- Security interceptor blocking dangerous commands
+- Multi-backend support (Local LLM, OpenRouter, etc.)
+- Human-in-the-loop approval for tool execution
+"""
+
+__version__ = "0.2.0"
+__author__ = "Wojciech Wiesner"
+
+from .backend import get_backend
+
+__all__ = ["get_backend", "__version__"]

agentzero_cli/backend.py

@@ -0,0 +1,122 @@
+"""
+Backend factory for AgentZeroCLI
+
+Priority order (by capability):
+1. OpenRouter - cloud LLMs, best quality, data leaves network
+2. Agent Zero API - self-hosted, good quality, your infrastructure  
+3. Local LLM - Ollama/LM Studio, SAFEST (data stays local), good quality
+4. Local Deterministic - pattern matching, offline, no LLM
+
+SECURITY NOTE:
+All backends go through the same security flow:
+  User Input → Backend → tool_request → ToolApprovalScreen → execute
+
+The security interceptor is NEVER bypassed regardless of backend.
+See docs/SECURITY.md for details.
+"""
+
+import os
+from typing import Protocol, AsyncGenerator, Any
+
+
+class BackendProtocol(Protocol):
+    """Protocol for all backends."""
+    
+    async def send_prompt(self, user_text: str) -> AsyncGenerator[Any, None]: ...
+    async def explain_risk(self, command: str) -> str: ...
+    async def execute_tool(self, tool_name: str, command: str, cwd: str | None = None) -> AsyncGenerator[Any, None]: ...
+    async def close(self) -> None: ...
+
+
+def get_backend() -> BackendProtocol:
+    """
+    Factory function to get the best available backend.
+    
+    Priority (checks in order, uses first available):
+    1. Local LLM (SAFEST) - if LOCAL_LLM_URL is set - data stays on your network
+    2. Agent Zero API - if AGENTZERO_API_URL is set - self-hosted
+    3. OpenRouter - if OPENROUTER_API_KEY is set - cloud LLMs, best quality
+    4. Local Deterministic - always available, pattern matching, no LLM
+    
+    All tool_requests go through ToolApprovalScreen regardless of backend.
+    """
+    from dotenv import load_dotenv
+    load_dotenv()
+    
+    # Priority 1: Local LLM (SAFEST - data never leaves your network)
+    local_llm_url = os.getenv("LOCAL_LLM_URL")
+    if local_llm_url:
+        try:
+            from .llm_providers.localllm import LocalLLMBackend
+            backend = LocalLLMBackend(base_url=local_llm_url)
+            print(f"[OK] Local LLM connected - {backend.model} (SAFEST)")
+            return backend
+        except ImportError as e:
+            print(f"[WARN] LocalLLM import failed: {e}")
+        except Exception as e:
+            print(f"[WARN] LocalLLM init failed: {e}")
+    
+    # Priority 2: Agent Zero API (self-hosted)
+    agentzero_url = os.getenv("AGENTZERO_API_URL")
+    if agentzero_url:
+        try:
+            from .llm_providers.agentzero import AgentZeroBackend
+            backend = AgentZeroBackend(api_url=agentzero_url)
+            print(f"[OK] Agent Zero connected ({agentzero_url})")
+            return backend
+        except ImportError as e:
+            print(f"[WARN] AgentZero import failed: {e}")
+        except Exception as e:
+            print(f"[WARN] AgentZero init failed: {e}")
+    
+    # Priority 3: OpenRouter (cloud - data leaves network)
+    openrouter_key = os.getenv("OPENROUTER_API_KEY")
+    if openrouter_key:
+        try:
+            from .llm_providers.openrouter import OpenRouterBackend
+            backend = OpenRouterBackend(api_key=openrouter_key)
+            print(f"[OK] OpenRouter connected ({len(backend.models)} models)")
+            return backend
+        except ImportError as e:
+            print(f"[WARN] OpenRouter import failed: {e}")
+        except Exception as e:
+            print(f"[WARN] OpenRouter init failed: {e}")
+    
+    # Priority 4: Local deterministic (no LLM, always works)
+    try:
+        from .llm_providers.local import LocalBackend
+        backend = LocalBackend()
+        print("[OK] Local mode (pattern matching, no LLM)")
+        print("[INFO] For AI responses, set LOCAL_LLM_URL, AGENTZERO_API_URL, or OPENROUTER_API_KEY")
+        return backend
+    except ImportError:
+        pass
+    
+    # Fallback: Minimal mock (should never reach here)
+    print("[WARN] No backend available, using minimal mock")
+    return MinimalMockBackend()
+
+
+class MinimalMockBackend:
+    """Absolute minimal fallback - should never be used in practice."""
+    
+    async def send_prompt(self, user_text: str):
+        yield {
+            "type": "final_response", 
+            "content": "No backend configured. Set OPENROUTER_API_KEY or AGENTZERO_API_URL in .env"
+        }
+    
+    async def explain_risk(self, command: str) -> str:
+        return f"Cannot analyze '{command}' - no backend configured."
+    
+    async def execute_tool(self, tool_name: str = "shell", command: str = "", cwd: str | None = None):
+        from .tools.executor import execute_tool as real_execute
+        async for event in real_execute(tool_name, command, cwd):
+            yield event
+    
+    async def close(self):
+        pass
+
+
+# Backwards compatibility
+__all__ = ["get_backend", "BackendProtocol"]

agentzero_cli/cli/__init__.py

@@ -0,0 +1,5 @@
+"""CLI module for AgentZeroCLI."""
+
+from .app import CLIApp
+
+__all__ = ["CLIApp"]

agentzero_cli/cli/app.py

@@ -0,0 +1,199 @@
+"""Main CLI application loop for AgentZeroCLI."""
+
+import sys
+from pathlib import Path
+
+import yaml
+from rich.console import Console
+
+from ..backend import get_backend
+
+from .approval import ToolApprovalHandler
+from .commands import CLISlashCommands
+from .input import InputHandler
+from .renderer import OutputRenderer
+from .setup_wizard import check_and_run_wizard
+
+
+def load_config(config_path: str = None) -> dict:
+    """Load configuration from YAML file.
+
+    Args:
+        config_path: Path to config file (auto-detects if None)
+
+    Returns:
+        Config dict (empty dict if file not found)
+    """
+    if config_path:
+        paths_to_try = [Path(config_path)]
+    else:
+        paths_to_try = [
+            Path("config.yaml"),
+            Path.home() / ".config" / "agentzero" / "config.yaml",
+        ]
+
+    for path in paths_to_try:
+        if path.exists():
+            with open(path, encoding="utf-8") as f:
+                return yaml.safe_load(f) or {}
+    return {}
+
+
+def save_config(config: dict, config_path: str = "config.yaml") -> None:
+    """Save configuration to YAML file.
+
+    Args:
+        config: Config dict to save
+        config_path: Path to config file
+    """
+    with open(config_path, "w", encoding="utf-8") as f:
+        yaml.dump(config, f, default_flow_style=False, allow_unicode=True, sort_keys=False)
+
+
+class CLIApp:
+    """Main CLI application - Claude Code-like interface for Agent Zero."""
+
+    def __init__(self, config_path: str = None):
+        """Initialize CLI application.
+
+        Args:
+            config_path: Path to config.yaml (auto-detected if None)
+        """
+        self.console = Console()
+
+        if config_path:
+            self.config_path = config_path
+        else:
+            resolved_path = check_and_run_wizard(self.console)
+            if resolved_path is None:
+                self.console.print("[red]Configuration required. Exiting.[/]")
+                sys.exit(1)
+            self.config_path = str(resolved_path)
+
+        self.config = load_config(self.config_path)
+        self.renderer = OutputRenderer(self.console)
+
+        # Initialize backend using factory
+        self.backend = get_backend()
+
+        # Initialize components
+        workspace = getattr(self.backend, 'workspace_root', str(Path.cwd()))
+        self.input_handler = InputHandler(workspace)
+        self.commands = CLISlashCommands()
+
+        # Connect commands to input completer
+        self.input_handler.set_commands(self.commands.commands)
+
+        self.approval = ToolApprovalHandler(
+            self.renderer,
+            self.input_handler,
+            self.backend,
+        )
+
+        self.running = True
+
+    async def run(self) -> None:
+        """Main application loop."""
+        # Show header
+        self.renderer.header(
+            self.backend.api_url or "not configured",
+            self.backend.project_name,
+            self.backend.security_mode,
+        )
+
+        # Main loop
+        while self.running:
+            try:
+                user_input = await self.input_handler.get_input("> ")
+
+                if not user_input:
+                    continue
+
+                # Check for slash commands
+                if await self.commands.execute(self, user_input):
+                    continue
+
+                # Process as agent message
+                await self.handle_message(user_input)
+
+            except KeyboardInterrupt:
+                self.renderer.goodbye()
+                break
+            except EOFError:
+                self.renderer.goodbye()
+                break
+            except Exception as e:
+                self.renderer.error(str(e))
+
+    async def handle_message(self, text: str) -> None:
+        """Send message to agent and handle response.
+
+        Args:
+            text: User message text
+        """
+        # Show user message
+        self.renderer.user_message(text)
+
+        # Stream events from backend
+        try:
+            with self.console.status("[bold cyan]Thinking...", spinner="dots"):
+                async for event in self.backend.send_prompt(text):
+                    await self._process_event(event)
+        except Exception as e:
+            self.renderer.error(f"Connection error: {e}")
+
+    async def _process_event(self, event: dict) -> None:
+        """Process a single event from backend.
+
+        Event types:
+        - status: Connection/processing status
+        - thinking/thought: Agent reasoning
+        - final_response: Agent's response
+        - tool_output: Tool execution output
+        - tool_request: Tool approval request
+        """
+        event_type = event.get("type", "")
+        content = event.get("content", "")
+
+        if event_type == "status":
+            # Filter keepalive spam, show news instead
+            if "Oczekiwanie na odpowiedź" in content:
+                from .news import get_random_news
+
+                item = get_random_news()
+                if item:
+                    self.renderer.news_item(item)
+                return
+            self.renderer.status(content)
+
+        elif event_type in ("thinking", "thought"):
+            self.renderer.thinking(content)
+
+        elif event_type == "final_response":
+            self.renderer.agent_response(content)
+
+        elif event_type == "tool_output":
+            self.renderer.tool_output(content)
+
+        elif event_type == "tool_request":
+            await self._handle_tool_request(event)
+
+    async def _handle_tool_request(self, event: dict) -> None:
+        """Handle tool approval and execution.
+
+        Args:
+            event: Tool request event
+        """
+        # Request approval
+        decision = await self.approval.request_approval(event)
+
+        if decision == "approved":
+            # Execute tool
+            with self.console.status("[bold cyan]Executing...", spinner="dots"):
+                async for exec_event in self.backend.execute_tool(event):
+                    await self._process_event(exec_event)
+        else:
+            with self.console.status("[bold yellow]Rejected...", spinner="dots"):
+                if hasattr(self.backend, "reject_tool"):
+                    async for exec_event in self.backend.reject_tool(event):
+                        await self._process_event(exec_event)